<!DOCTYPE HTML>
<html lang="Chinese">


<head>
    <meta charset="utf-8">
    <meta name="keywords" content="计算机基础, 博客">
    <meta name="description" content="In me the tiger sniffs the rose.">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
    <meta name="renderer" content="webkit|ie-stand|ie-comp">
    <meta name="mobile-web-app-capable" content="yes">
    <meta name="format-detection" content="telephone=no">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
    <!-- Global site tag (gtag.js) - Google Analytics -->


    <title>计算机基础 | 凡诚</title>
    <link rel="icon" type="image/png" href="/favicon.png">

    <link rel="stylesheet" type="text/css" href="/libs/awesome/css/all.css">
    <link rel="stylesheet" type="text/css" href="/libs/materialize/materialize.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/aos/aos.css">
    <link rel="stylesheet" type="text/css" href="/libs/animate/animate.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/lightGallery/css/lightgallery.min.css">
    <link rel="stylesheet" type="text/css" href="/css/matery.css">
    <link rel="stylesheet" type="text/css" href="/css/my.css">
    <script src="https://sdk.jinrishici.com/v2/browser/jinrishici.js" charset="utf-8"></script>
    <script src="/libs/jquery/jquery.min.js"></script>

<meta name="generator" content="Hexo 5.4.2"></head>



   <style>
    body{
       background-image: url(https://cdn.jsdelivr.net/gh/Tokisaki-Galaxy/res/site/medias/background.jpg);
       background-repeat:no-repeat;
       background-size:cover;
       background-attachment:fixed;
    }
</style>



<body>
    <header class="navbar-fixed">
    <nav id="headNav" class="bg-color nav-transparent">
        <div id="navContainer" class="nav-wrapper container">
            <div class="brand-logo">
                <a href="/" class="waves-effect waves-light">
                    
                    <img src="/medias/comment_bg.png" class="logo-img" alt="LOGO">
                    
                    <span class="logo-span">凡诚</span>
                </a>
            </div>
            

<a href="#" data-target="mobile-nav" class="sidenav-trigger button-collapse"><i class="fas fa-bars"></i></a>
<ul class="right nav-menu">
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/" class="waves-effect waves-light">
      
      <i class="fas fa-home" style="zoom: 0.6;"></i>
      
      <span>主页</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/tags" class="waves-effect waves-light">
      
      <i class="fas fa-tags" style="zoom: 0.6;"></i>
      
      <span>文章</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/categories" class="waves-effect waves-light">
      
      <i class="fas fa-bookmark" style="zoom: 0.6;"></i>
      
      <span>分类</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/archives" class="waves-effect waves-light">
      
      <i class="fas fa-archive" style="zoom: 0.6;"></i>
      
      <span>归档</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="" class="waves-effect waves-light">

      
      <i class="fas fa-user-circle" style="zoom: 0.6;"></i>
      
      <span>关于我</span>
      <i class="fas fa-chevron-down" aria-hidden="true" style="zoom: 0.6;"></i>
    </a>
    <ul class="sub-nav menus_item_child ">
      
      <li>
        <a href="/about">
          
          <i class="fas fa-user-circle" style="margin-top: -20px; zoom: 0.6;"></i>
          
          <span>我的信息</span>
        </a>
      </li>
      
      <li>
        <a href="/contact">
          
          <i class="fas fa-comments" style="margin-top: -20px; zoom: 0.6;"></i>
          
          <span>留言板</span>
        </a>
      </li>
      
      <li>
        <a href="/friends">
          
          <i class="fas fa-address-book" style="margin-top: -20px; zoom: 0.6;"></i>
          
          <span>友链</span>
        </a>
      </li>
      
    </ul>
    
  </li>
  
  <li>
    <a href="#searchModal" class="modal-trigger waves-effect waves-light">
      <i id="searchIcon" class="fas fa-search" title="Search" style="zoom: 0.85;"></i>
    </a>
  </li>
</ul>


<div id="mobile-nav" class="side-nav sidenav">

    <div class="mobile-head bg-color">
        
        <img src="/medias/comment_bg.png" class="logo-img circle responsive-img">
        
        <div class="logo-name">凡诚</div>
        <div class="logo-desc">
            
            In me the tiger sniffs the rose.
            
        </div>
    </div>

    

    <ul class="menu-list mobile-menu-list">
        
        <li class="m-nav-item">
	  
		<a href="/" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-home"></i>
			
			主页
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/tags" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-tags"></i>
			
			文章
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/categories" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-bookmark"></i>
			
			分类
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/archives" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-archive"></i>
			
			归档
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="javascript:;">
			
				<i class="fa-fw fas fa-user-circle"></i>
			
			关于我
			<span class="m-icon"><i class="fas fa-chevron-right"></i></span>
		</a>
            <ul  style="background:  ;" >
              
                <li>

                  <a href="/about " style="margin-left:75px">
				  
				   <i class="fa fas fa-user-circle" style="position: absolute;left:50px" ></i>
			      
		          <span>我的信息</span>
                  </a>
                </li>
              
                <li>

                  <a href="/contact " style="margin-left:75px">
				  
				   <i class="fa fas fa-comments" style="position: absolute;left:50px" ></i>
			      
		          <span>留言板</span>
                  </a>
                </li>
              
                <li>

                  <a href="/friends " style="margin-left:75px">
				  
				   <i class="fa fas fa-address-book" style="position: absolute;left:50px" ></i>
			      
		          <span>友链</span>
                  </a>
                </li>
              
            </ul>
          
        </li>
        
        
    </ul>
</div>


        </div>

        
    </nav>

</header>

    



<div class="bg-cover pd-header post-cover" style="background-image: url('/medias/featureimages/2.jpg')">
    <div class="container" style="right: 0px;left: 0px;">
        <div class="row">
            <div class="col s12 m12 l12">
                <div class="brand">
                    <h1 class="description center-align post-title">计算机基础</h1>
                </div>
            </div>
        </div>
    </div>
</div>




<main class="post-container content">

    
    <link rel="stylesheet" href="/libs/tocbot/tocbot.css">
<style>
    #articleContent h1::before,
    #articleContent h2::before,
    #articleContent h3::before,
    #articleContent h4::before,
    #articleContent h5::before,
    #articleContent h6::before {
        display: block;
        content: " ";
        height: 100px;
        margin-top: -100px;
        visibility: hidden;
    }

    #articleContent :focus {
        outline: none;
    }

    .toc-fixed {
        position: fixed;
        top: 64px;
    }

    .toc-widget {
        width: 345px;
        padding-left: 20px;
    }

    .toc-widget .toc-title {
        padding: 35px 0 15px 17px;
        font-size: 1.5rem;
        font-weight: bold;
        line-height: 1.5rem;
    }

    .toc-widget ol {
        padding: 0;
        list-style: none;
    }

    #toc-content {
        padding-bottom: 30px;
        overflow: auto;
    }

    #toc-content ol {
        padding-left: 10px;
    }

    #toc-content ol li {
        padding-left: 10px;
    }

    #toc-content .toc-link:hover {
        color: #42b983;
        font-weight: 700;
        text-decoration: underline;
    }

    #toc-content .toc-link::before {
        background-color: transparent;
        max-height: 25px;

        position: absolute;
        right: 23.5vw;
        display: block;
    }

    #toc-content .is-active-link {
        color: #42b983;
    }

    #floating-toc-btn {
        position: fixed;
        right: 15px;
        bottom: 76px;
        padding-top: 15px;
        margin-bottom: 0;
        z-index: 998;
    }

    #floating-toc-btn .btn-floating {
        width: 48px;
        height: 48px;
    }

    #floating-toc-btn .btn-floating i {
        line-height: 48px;
        font-size: 1.4rem;
    }
</style>
<div class="row">
    <div id="main-content" class="col s12 m12 l9">
        <!-- 文章内容详情 -->
<div id="artDetail">
    <div class="card">
        <div class="card-content article-info">
            <div class="row tag-cate">
                <div class="col s7">
                    
                    <div class="article-tag">
                        
                            <a href="/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%9F%BA%E7%A1%80/">
                                <span class="chip bg-color">计算机基础</span>
                            </a>
                        
                    </div>
                    
                </div>
                <div class="col s5 right-align">
                    
                    <div class="post-cate">
                        <i class="fas fa-bookmark fa-fw icon-category"></i>
                        
                            <a href="/categories/%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%9F%BA%E7%A1%80/" class="post-category">
                                计算机基础
                            </a>
                        
                    </div>
                    
                </div>
            </div>

            <div class="post-info">
                
                <div class="post-date info-break-policy">
                    <i class="far fa-calendar-minus fa-fw"></i>Publish Date:&nbsp;&nbsp;
                    2020-03-11
                </div>
                

                
                <div class="post-date info-break-policy">
                    <i class="far fa-calendar-check fa-fw"></i>Update Date:&nbsp;&nbsp;
                    2022-11-08
                </div>
                

                
                <div class="info-break-policy">
                    <i class="far fa-file-word fa-fw"></i>Word Count:&nbsp;&nbsp;
                    18.3k
                </div>
                

                
                <div class="info-break-policy">
                    <i class="far fa-clock fa-fw"></i>Read Times:&nbsp;&nbsp;
                    64 Min
                </div>
                

                
                    <div id="busuanzi_container_page_pv" class="info-break-policy">
                        <i class="far fa-eye fa-fw"></i>Read Count:&nbsp;&nbsp;
                        <span id="busuanzi_value_page_pv"></span>
                    </div>
				
            </div>
        </div>
        <hr class="clearfix">

        
        <!-- 是否加载使用自带的 prismjs. -->
        <link rel="stylesheet" href="/libs/prism/prism.css">
        

        

        <div class="card-content article-card-content">
            <div id="articleContent">
                <h2 id="计算机知识"><a href="#计算机知识" class="headerlink" title="计算机知识"></a>计算机知识</h2><h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>计算机知识是编程入门的必备知识，只有了解了计算机相关的知识，才会明白程序背后的原理，才能更深刻的理解编程</p>
<h3 id="目录说明"><a href="#目录说明" class="headerlink" title="目录说明"></a>目录说明</h3><ol>
<li><p>冯·诺伊曼体系</p>
<p>冯·诺伊曼，计算机之父，现今所有的计算机都是建立在冯诺伊曼体系之上</p>
</li>
<li><p>CPU</p>
<p>计算机的大脑，也是实际的工作者，计算机所有的行为都需要依靠CPU来运行以及控制</p>
</li>
<li><h6 id="内存管理"><a href="#内存管理" class="headerlink" title="内存管理"></a>内存管理</h6><p>内存很快，磁盘访问很慢，计算机运行速度快和内存脱不了关系，内存往往作为CPU和其他设备之间交互的中转站</p>
</li>
<li><p>进程管理</p>
<p>当运行一个程序，进程启动了</p>
</li>
<li><p>文件管理</p>
<p>将数据存储到磁盘上，永久保存</p>
</li>
<li><p>输入输出管理</p>
<p>键盘，鼠标，打印机等等，通过设备控制器和驱动程序和CPU交互</p>
</li>
</ol>
<h3 id="1-冯·诺伊曼体系"><a href="#1-冯·诺伊曼体系" class="headerlink" title="1. 冯·诺伊曼体系"></a>1. 冯·诺伊曼体系</h3><p><img src="img/tixi.png" alt="img"></p>
<h4 id="1-1-简介"><a href="#1-1-简介" class="headerlink" title="1.1 简介"></a>1.1 简介</h4><p>现代计算机之父<code>冯诺伊曼</code>最先提出程序存储的思想，并成功将其运用在计算机的设计之中，该思想约定了用二进制进行计算和存储，还定义计算机基本结构为 5 个部分，分别是<strong>中央处理器（CPU）、存储器、运算器、输入设备、输出设备</strong>。</p>
<p><strong>现今定义这五部分为：CPU，存储器，输出设备，输入设备，总线</strong></p>
<ol>
<li><p><strong>CPU</strong>：中央处理器，类比人脑，作为计算机系统的运算和控制核心，是信息处理、程序运行的最终执行单元。CPU由控制单元，逻辑运算单元，寄存器组成。CPU用寄存器存储计算时所需数据，寄存器一般有三种：</p>
<blockquote>
<p>通用寄存器：用来存放需要进行运算的数据，比如需进行加法运算的两个数据。</p>
<p>程序计数器：用来存储 CPU 要执行下一条指令所在的内存地址。</p>
<p>指令寄存器：用来存放程序计数器指向的指令本身。</p>
</blockquote>
</li>
<li><p><strong>存储器</strong>：代码跟数据在RAM（随机存取存储器）跟ROM（只读存储器）中是线性存储， 数据存储的单位是一个二进制位。最小的存储单位是字节。</p>
</li>
<li><p><strong>输入/输出设备</strong>：输入设备向计算机输入数据，计算机经过计算后，把数据输出给输出设备。比如键盘按键时需要和 CPU 进行交互，这时就需要用到控制总线。</p>
</li>
<li><p><strong>总线</strong>：总线是用于 CPU 和内存以及其他设备之间的通信，总线主要有三种：</p>
<blockquote>
<p><strong>地址总线</strong>：用于指定 CPU 将要操作的内存地址。</p>
<p><strong>数据总线</strong>：用于读写内存的数据。</p>
<p><strong>控制总线</strong>：用于发送和接收信号，比如中断、设备复位等信号，CPU 收到信号后响应，这时也需要控制总线。</p>
</blockquote>
</li>
</ol>
<h4 id="1-2-指令执行流程"><a href="#1-2-指令执行流程" class="headerlink" title="1.2 指令执行流程"></a>1.2 指令执行流程</h4><p><img src="img/cpu-01.png" alt="img"></p>
<ol>
<li>CPU读取程序计数器获得指令内存地址，CPU控制单元操作地址总线从内存地址拿到数据，数据通过数据总线到达CPU被存入指令寄存器。</li>
<li>CPU分析指令寄存器中的指令，如果是计算类型的指令交给逻辑运算单元，如果是存储类型的指令交给控制单元执行。</li>
<li>CPU 执行完指令后程序计数器的值通过自增指向下个指令，比如32位CPU会自增4。</li>
<li>自增后开始顺序执行下一条指令，不断循环执行直到程序结束。</li>
</ol>
<p><img src="img/CPU-02.png" alt="img"></p>
<p><strong>CPU位宽</strong>：32位CPU一次可操作计算4个字节，64位CPU一次可操作计算8个字节，这个是硬件级别的。平常我们说的32位或64位操作系统指的是软件级别的，指的是程序中指令多少位。</p>
<p><strong>线路位宽</strong>：CPU操作指令数据通过高低电压变化进行数据传输，传输时候可以串行传输，也可以并行传输，多少个并行等于多少个位宽。</p>
<h3 id="2-CPU"><a href="#2-CPU" class="headerlink" title="2. CPU"></a>2. CPU</h3><h4 id="2-1-CPU简介"><a href="#2-1-CPU简介" class="headerlink" title="2.1 CPU简介"></a>2.1 CPU简介</h4><blockquote>
<p>Central Processing Unit 中央处理器，作为计算机系统的运算和控制核心，是信息处理、程序运行的最终执行单元</p>
</blockquote>
<p><img src="img/cpu-03.png" alt="img"></p>
<ol>
<li><p><code>CPU核心</code>：一般一个CPU会有多个CPU核心，平常说的多核是指在一枚处理器中集成两个或多个完整的计算引擎。核跟CPU的关系是：核属于CPU的一部分。</p>
</li>
<li><p><code>寄存器</code>：最靠近CPU对存储单元，32位CPU寄存器可存储4字节，64位寄存器可存储8字节。寄存器访问速度一般是半个CPU时钟周期，属于纳秒级别，</p>
</li>
<li><p><code>L1缓存</code>：每个CPU核心都有，用来缓存数据跟指令，访问空间大小一般在32～256KB，访问速度一般是2～4个CPU时钟周期。</p>
<pre class="line-numbers language-none"><code class="language-none">cat &#x2F;sys&#x2F;devices&#x2F;system&#x2F;cpu&#x2F;cpu0&#x2F;cache&#x2F;index0&#x2F;size # L1 数据缓存
cat &#x2F;sys&#x2F;devices&#x2F;system&#x2F;cpu&#x2F;cpu0&#x2F;cache&#x2F;index1&#x2F;size # L1 指令缓存<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre></li>
<li><p><code>L2缓存</code>：每个CPU核心都有，访问空间大小在128KB～2MB，访问速度一般是10～20个CPU时钟周期。</p>
<pre class="line-numbers language-none"><code class="language-none">cat &#x2F;sys&#x2F;devices&#x2F;system&#x2F;cpu&#x2F;cpu0&#x2F;cache&#x2F;index2&#x2F;size # L2 缓存容量大小<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li>
<li><p><code>L3缓存</code>：多个CPU核心共用，访问空间大小在2MB～64MB，访问速度一般是20～60个CPU时钟周期。</p>
<pre class="line-numbers language-none"><code class="language-none">cat &#x2F;sys&#x2F;devices&#x2F;system&#x2F;cpu&#x2F;cpu0&#x2F;cache&#x2F;index3&#x2F;size # L3 缓存容量大小<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li>
<li><p><code>内存</code>：多个CPU共用，现在一般是4G～512G，访问速度一般是200～300个CPU时钟周期。</p>
</li>
<li><p><code>固体硬盘SSD</code>：现在台式机主流都会配备，上述的寄存器、缓存、内存都是断电数据立马丢失的，而SSD里不会丢失，大小一般是128G～1T，比内存慢10～1000倍。</p>
</li>
<li><p><code>机械盘HDD</code>：很早以前流行的硬盘了，容量可在512G～8T不等，访问速度比内存慢10W倍不等。</p>
</li>
<li><p><code>访问数据顺序</code>：CPU在拿数据处理的时候几乎也是按照上面说得流程来操纵的，只有上面一层找不到才会找下一层。</p>
</li>
<li><p><code>Cache Line</code> :  CPU读取数据时会按照 Cache Line 方式把数据加载到缓存中，每个Cacheline = 64KB，因为L1、L2是每个核独有到可能会触发<strong>伪共享</strong>，所以可能会将数据划分到不同到CacheLine中来避免伪共享，比如在JDK8 新增加的 LongAdder 就涉及到此知识点。</p>
</li>
</ol>
<blockquote>
<ol>
<li><strong>伪共享</strong>：缓存系统中是以缓存行（cache line）为单位存储的，当多线程修改互相独立的变量时，如果这些变量共享同一个缓存行，就会无意中影响彼此的性能，这就是伪共享。</li>
</ol>
</blockquote>
<p>java内存模型： <code>JMM</code>:  数据经过种种分层会导致访问速度在不断提升，同时也带来了各种问题，多个CPU同时操作相同数据可能会造成各种安全问题，需要加锁。</p>
<h4 id="2-2-CPU-访问方式"><a href="#2-2-CPU-访问方式" class="headerlink" title="2.2 CPU 访问方式"></a>2.2 CPU 访问方式</h4><p><img src="img/cpu-04.png" alt="img"></p>
<p>CPU访问方式</p>
<p>内存数据映射到CPU Cache 时通过公式 <code>Block N % CacheLineMax</code>决定内存Block数据放到那个CPU Cache Line 里。CPU Cache 主要有4部分组成。</p>
<ol>
<li><strong>Cache Line Index</strong> ：CPU缓存读取数据时不是按照字节来读取的，而是按照CacheLine方式存储跟读取数据的。</li>
<li><strong>Valid Bit</strong> : 有效位标志符，值为0时表示无论 CPU Line 中是否有数据，CPU 都会直接访问内存，重新加载数据。</li>
<li><strong>Tag</strong>：组标记，用来标记内存中不同BLock映射到相同CacheLine，用Tag来区分不同的内存Block。</li>
<li><strong>Data</strong>：真实到内存数据信息。</li>
</ol>
<p>CPU真实访问内存数据时只需要指定三个部分即可。</p>
<ol>
<li><strong>Cache Line Index</strong> ：要访问到Cache Line 位置。</li>
<li><strong>Tag</strong>：表示用那个数据块。</li>
<li><strong>Offset</strong>：CPU从CPU Cache 读取数据时不是直接读取Cache Line整个数据块，而是读取CPU所需的数据片段，称为Word。如何找到Word就需要个偏移量Offset。</li>
</ol>
<h4 id="2-3-CPU-访问速度"><a href="#2-3-CPU-访问速度" class="headerlink" title="2.3 CPU 访问速度"></a>2.3 CPU 访问速度</h4><p><img src="img/cpu-05.png" alt="img"></p>
<p>如上图所示，CPU访问速度是逐步变慢，所以CPU访问数据时需尽量在距离CPU近的高速缓存区访问，根据摩尔定律CPU访问速度每18个月就会翻倍，而内存的访问每18个月也就增长10% 左右，导致的结果就是CPU跟内存访问性能差距逐步变大，那如何尽可能提高CPU缓存命中率呢？</p>
<ol>
<li><code>数据缓存</code>：遍历数据时候按照内存布局顺序访问，因为CPU Cache是根据Cache Line批量操作数据的，所以你顺序读取数据会提速，道理跟磁盘顺序写一样。</li>
<li><code>指令缓存</code>：尽可能的提供有规律的条件分支语句，让 CPU 的分支预测器发挥作用，进一步提高执行的效率，因为CPU是自带<code>分支预测器</code>，自动提前将可能需要的指令放到指令缓存区。</li>
<li><code>线程绑定到CPU</code>：一个任务A在前一个时间片用CPU核心1 运行，后一个时间片用CPU核心2 运行，这样缓存L1、L2就浪费了。因此操作系统提供了将进程或者线程绑定到某一颗 CPU 上运行的能力。如 Linux 上提供了 sched_setaffinity 方法实现这一功能，其他操作系统也有类似功能的 API 可用。当多线程同时执行密集计算，且 CPU 缓存命中率很高时，如果将每个线程分别绑定在不同的 CPU 核心上，性能便会获得非常可观的提升。</li>
</ol>
<h3 id="3-操作系统"><a href="#3-操作系统" class="headerlink" title="3. 操作系统"></a>3. 操作系统</h3><p>电脑想要运行就必须安装操作系统，操作系统英文名为Operation System，简称OS。</p>
<p>操作系统是覆盖在硬件上的一层特殊软件，它管理计算机的硬件和软件资源，为其他应用程序提供大量服务。</p>
<p>操作系统：</p>
<ol>
<li><p>Windows  （Win7，Win10）</p>
<ol start="2">
<li>Linux  (Ubuntu乌邦图，Debian，RedHat，CentOS)</li>
<li>MacOS 基于 Unix</li>
</ol>
</li>
</ol>
<p>操作系统是如何进行 <strong>内存管理</strong>、 <strong>进程管理</strong>、 <strong>文件管理</strong>、 <strong>输入输出管理</strong>的呢？</p>
<h4 id="3-1-内存管理"><a href="#3-1-内存管理" class="headerlink" title="3.1  内存管理"></a>3.1  内存管理</h4><p>你的电脑是32位操作系统，那可支持的最大内存就是4G，你有没有好奇为什么可以同时运行2个以上的2G内存的程序。应用程序不是直接使用的物理地址，操作系统为每个运行的进程分配了一套<code>虚拟地址</code>，每个进程都有自己的<code>虚拟内存地址</code>，进程是无法直接进行<code>物理内存地址</code>的访问的。至于虚拟地址跟物理地址的映射，进程是感知不到的！<code>操作系统自身会提供一套机制将不同进程的虚拟地址和不同内存的物理地址进行映射</code>。</p>
<p><img src="img/ee27e923-8933-4807-b9e1-91fea19f7d9e.png" alt="img"></p>
<p>​                                                                                        虚拟内存</p>
<h5 id="3-1-1-MMU"><a href="#3-1-1-MMU" class="headerlink" title="3.1.1 MMU"></a>3.1.1 MMU</h5><p><code>Memory Management Unit 内存管理单元</code>是一种负责处理CPU内存访问请求的计算机硬件。它的功能包括<strong>虚拟地址到物理地址的转换、内存保护、中央处理器高速缓存的控制</strong>。现代 CPU 基本上都选择了使用 MMU。</p>
<p>当进程持有虚拟内存地址的时候，CPU执行该进程时会操作虚拟内存，而MMU会自动的将虚拟内存的操作映射到物理内存上。</p>
<p><img src="img/aec16614-baaa-408d-964c-e2eae929e2bb.png" alt="img"></p>
<p>​                                                                                        MMU</p>
<p>这里提一下，Java操作的时候你看到的地址是 <code>JVM地址</code>，不是真正的物理地址。</p>
<h5 id="3-1-2-内存管理方式"><a href="#3-1-2-内存管理方式" class="headerlink" title="3.1.2 内存管理方式"></a>3.1.2 内存管理方式</h5><p>操作系统主要采用<code>内存分段</code>和<code>内存分页</code>来管理虚拟地址与物理地址之间的关系，其中分段是很早前的方法了，现在大部分用的是分页，不过分页也不是完全的分页，是在分段的基础上再分页。</p>
<h6 id="3-1-2-1-内存分段"><a href="#3-1-2-1-内存分段" class="headerlink" title="3.1.2.1 内存分段"></a>3.1.2.1 内存分段</h6><p><img src="img/f00c56b6-aaa0-40aa-a991-7235c9d2e08d.png" alt="img"></p>
<p>我们以上图的<a target="_blank" rel="noopener" href="https://www.oschina.net/action/GoToLink?url=https://mp.weixin.qq.com/s?__biz=MzI4NjI1OTI4Nw==&mid=2247489183&idx=1&sn=02ab3551c473bd2c8429862e3689a94b&scene=21%23wechat_redirect">JVM</a>内存模型举例，程序员会认为我们的代码是由代码段、数据段、栈段、堆段组成。不同的段是有不同的属性的，用户并不关心这些元素所在内存的位置，而分段就是支持这种用户视图的内存管理方案。逻辑地址空间是由一组段构成。每个段都有名称和长度。地址指定了段名称和段内偏移。因此用户<code>段编号</code>和<code>段偏移</code>来指定不同属性的地址。而虚拟内存地址跟物理内存地址中间是通过段表进行映射的，口说无凭，看图吧。</p>
<p><img src="img/75249fa9-fb1a-49d7-a179-dcf4942aca80.png" alt="img"></p>
<p>​                                                                    内存分段管理</p>
<p>如上虚拟地址有 5 个段，各段按如图所示来存储。每个段都在段表中有一个条目，它包括段在物理内存内的开始的基地址和该段的界限长度。例如段 2 为 400 字节长，开始于位置 4300。因此对段 2 字节 53 的引用映射成位置 4300 + 53 = 4353。对段 3 字节 852 的引用映射成位置 3200 + 852 = 4052。</p>
<p>分段映射很简单，但是会导致<code>内存碎片</code>跟<code>内存交互效率低</code>。这里先普及下在内存管理中主要有<code>内部内存碎片</code>跟<code>外部内存碎片</code>。</p>
<ol>
<li><strong>内部碎片</strong>：已经被分配出去的的内存空间不经常使用，并且分配出去的内存空间大于请求所需的内存空间。</li>
<li><strong>外部碎片</strong>：指可用空间还没有分配出去，但是可用空间由于大小太小而无法分配给申请空间的新进程的内存空间空闲块。</li>
</ol>
<p>以上图为例，现在系统空闲是1400 +  800 + 600 = 2800。那如果有个程序想要连续的使用2000，内存分段模式下提供不了啊！上述三个是<code>外部内存碎片</code>。当然可以使用系统的<code>Swap</code>空间，先把段0写入到磁盘，然后再重新给段0分配空间。这样可以实现最终可用，可是但凡涉及到磁盘读写就会导致<code>内存交互效率低</code>。</p>
<p><img src="img/e2acaefa-13cc-4f3e-bc05-65f4c72d9da2.png" alt="img"></p>
<p>​                                                                        swap空间利用</p>
<h6 id="3-1-2-2-内存分页"><a href="#3-1-2-2-内存分页" class="headerlink" title="3.1.2.2 内存分页"></a>3.1.2.2 内存分页</h6><p>内存分页，<code>整个虚拟内存和物理内存切成一段段固定尺寸的大小</code>。每个固定大小的尺寸称之为<code>页Page</code>，在 Linux 系统中Page = 4KB。然后虚拟内存跟物理内存之间通过<code>页表</code>来实现映射。</p>
<p>采用<strong>内存分页</strong>时内存的释放跟使用都是以页为单位的，也就不会产生内存碎片了。当空间还不够时根据操作系统调度算法，可能将最少用的内存页面 swap-out换出到磁盘，用时候再swap-in换入，尽可能的减少磁盘刷写量，提高内存交互效率。</p>
<p>分页模式下虚拟地址主要有<code>页号</code>跟<code>页内偏移量</code>两部分组成。通过页号查询页表找到物理内存地址，然后再配合页内偏移量就找到了真正的物理内存地址。</p>
<p><img src="img/dcc8a3f3-6226-4245-a675-921780df36d9.png" alt="img"></p>
<p>​                                                                                分页内存寻址</p>
<p>32位操作系统环境下进程可操作的虚拟地址是4GB，假设一个虚拟页大小为4KB，那需要4GB/4KB = <code>2^20</code> 个页信息。一行页表记录为4字节，<code>2^20</code>等价于4MB页表存储信息。这只是一个进程需要的，如果10个、100个、1000个呢？仅仅是页表存储都占据超大内存了。</p>
<p>为了解决这个问题就需要用到 <code>多级页表</code>，核心思想就是<strong>局部性</strong>分配。在32位的操作系统中将将4G空间分为 1024 行页目录项目(4KB)，每个页目录项又对应1024行页表项。如下图所示：</p>
<p><img src="img/6de61308-c124-401b-9cd9-63d69834f22d.png" alt="img"></p>
<p>​                                                                            32位系统二级分页</p>
<p>控制寄存器cr3中存放了页目录的物理地址，通过cr3寄存器可以找到页目录，而32位线性地址中的Directory部分决定页目录中的目录项，而页目录项中存放了要找的页表的物理基地址，再结合线性地址中的中间10位页表项，就可以找到页框的页表项。线性地址中的Offset部分占12位，因此页框的物理地址 + 线性地址Offset部分 = 页框中的任何一个字节。</p>
<p>分页后一级页就等价于4G虚拟地址空间，并且如果一级页表中那些地址没有就不需要再创建二级页表了！核心思想就是按需创建，当系统给每个进程分配4G空间，进程不可能占据全部内存的，如果一级目录页只有10%用到了，此时页表空间 = 一级页表4KB + 0.1 * 4MB  。这比单独的每个进程占据4M好用多了！</p>
<p>多层分页的弊端就是访问时间的<strong>增加</strong>。</p>
<ol>
<li>使用页表时读取内存中一页内容需要2次访问内存，访问页表项 + 并读取的一页数据。</li>
<li>使用二级页表的话需要三次访问，访问页目录项 + 访问页表项 + 访问并读取的一页数据。访存次数的增加也就意味着访问数据所花费的总时间增加。</li>
</ol>
<p>而对于64位系统，二级分页就无法满足了，Linux 从2.6.11开始采用四级分页模型。</p>
<ol>
<li>Page Global Directory 全局页目录项</li>
<li>Page Upper Directory 上层页目录项</li>
<li>Page Middle Directory 中间页目录项</li>
<li>Page Table Entry 页表项</li>
<li>Offset 偏移量。</li>
</ol>
<p><img src="img/cd5d7764-f6c3-4295-a66a-98818a1122a0.png" alt="img"></p>
<p>​                                                                                    64位寻址</p>
<h6 id="3-1-2-3-TLB"><a href="#3-1-2-3-TLB" class="headerlink" title="3.1.2.3 TLB"></a>3.1.2.3 TLB</h6><p>Translation Lookaside Buffer 可翻译为<code>地址转换后援缓冲器</code>，简称为<code>快表</code>，属于CPU内部的一个模块，TLB是MMU的一部分，实质是cache，它所缓存的是最近使用的数据的页表项（虚拟地址到物理地址的映射）。他的出现是为了加快访问数据（内存）的速度，减少重复的页表查找。当然它不是必须要有的，但有它，速度就更快。</p>
<p><img src="img/b23ad885-fbb3-4f01-835e-cc44c681fad9.png" alt="img"></p>
<p>​                                                                                        TLB</p>
<p>TLB很小，因此缓存的东西也不多。主要缓存最近使用的数据的数据映射。TLB结构如下图：</p>
<p><img src="img/66aeeb74-4b08-48e6-b2db-6b66bc7c0a7c.png" alt="img"></p>
<p>​                                                                                            TLB查询</p>
<p>如果一个需要访问内存中的一个数据，给定这个数据的虚拟地址，查询TLB，发现有hit，直接得到物理地址，在内存根据物理地址取数据。如果TLB没有这个虚拟地址miss，那么只能费力的通过页表来查找了。日常CPU读取一个数据的流程如下：</p>
<p><img src="img/b690ff04-fa06-4fe3-804d-761d1b019774.png" alt="img"></p>
<p>​                                                                                        CPU读取数据流程图</p>
<p>当进程地址空间进行了 <code>上下文切换</code>时，比如现在是进程1运行，TLB中放的是进程1的相关数据的地址，突然切换到进程2，TLB中原有的数据不是进程2相关的，此时TLB刷新数据有两种办法。</p>
<ol>
<li><strong>全部刷新</strong>：很简单，但花销大，很多不必刷新的数据也进行刷新，增加了无畏的花销。</li>
<li><strong>部分刷新</strong>：根据标志位，刷新需要刷新的数据，保留不需要刷新的数据。</li>
</ol>
<h6 id="3-1-2-4-段页式管理"><a href="#3-1-2-4-段页式管理" class="headerlink" title="3.1.2.4 段页式管理"></a>3.1.2.4 段页式管理</h6><p><code>内存分段</code>跟<code>内存分页</code>不是对立的，这俩可以组合起来在同一个系统中使用的，那么组合起来后通常称为<code>段页式内存管理</code>。段页式内存管理实现的方式：</p>
<ol>
<li>先对数据不同划分出不同的段，也就是前面说的分段机制。</li>
<li>然后再把每一个段进行分页操作，也就是前面说的分页机制。</li>
<li>此时 地址结构 = 段号 + 段内页号 + 页内位移。</li>
</ol>
<p>每一个进程有一张段表，每个段又建立一张页表，段表中的地址是页表的起始地址，而页表中的地址则为某页的物理页号。</p>
<p><img src="img/1bbcbcdd-416a-4e68-be65-c48671b2a685.png" alt="img"></p>
<p>​                                                                                    段页式管理</p>
<p>同时我们经常看到两个专业词 <code>逻辑地址</code>跟 <code>线性地址</code>。</p>
<ol>
<li><code>逻辑地址</code>：指的是没被段式内存管理映射的地址。</li>
<li><code>线性地址</code>：通过段式内存管理映射且页式内存管理转换前的地址，俗称虚拟地址。</li>
</ol>
<p>目前 Intel X86 CPU 采用的是内存分段 +  内存分页的管理方式，其中分页的意思是在由段式内存管理所映射而成的的地址上再加上一层地址映射。</p>
<p><img src="img/69e6dd7e-462b-4d66-b288-3aeab69971c6.png" alt="img"></p>
<p>​                                                                        X86内存管理方式</p>
<h6 id="3-1-2-5-Linux-内存管理"><a href="#3-1-2-5-Linux-内存管理" class="headerlink" title="3.1.2.5 Linux 内存管理"></a>3.1.2.5 Linux 内存管理</h6><p>先说结论：Linux系统基于X86 CPU 而做的操作系统，所以也是用的段页式内存管理方式。</p>
<p><img src="img/8049bb0a-db7a-4e5b-9cea-c706e5486dd9.png" alt="img"></p>
<p>我们知道32位的操作系统可寻址范围是4G，操作系统会将4G的可访问内存空间分为 <strong>用户空间</strong>跟 <strong>内核空间</strong>。</p>
<ol>
<li><code>内核空间</code>：操作系统内核访问的区域，独立于普通的应用程序，是受保护的内存空间。内核态下CPU可执行任何指令，可自由访问任何有效地址。</li>
<li><code>用户空间</code>：普通应用程序可访问的内存区域。被执行代码会受到CPU众多限制，进程只能访问映射其地址空间的页表项中规定的在用户态下可访问页面的虚拟地址。</li>
</ol>
<p>那为啥要搞俩空间呢?现在嵌入式环境跟以前的WIN98系统是没有区分俩空间的，须知俩空间是CPU分的，而操作系统是在上面运行的，单一用户、单一任务服务的操作系统，是没有分所谓用户态和内核态的必要。</p>
<p>用户态和内核态是因为有多用户，多任务的需求，然后在CPU硬件厂商配合之后，产生的一个操作系统解决多用户多任务需求的方案。方案就是<strong>限制</strong>，通过硬件手段（也只能硬件手段才能做到），限制某些代码，使其无法控制整个物理硬件，进而使各个不同用户，不同任务的代码，无权修改整个物理硬件，再进而保护操作系统的核心底层代码和其他用户的数据不被无意或者有意地破坏和盗取。</p>
<p><img src="img/237b960e-567e-4c17-849a-c94c760ad3e8.png" alt="img"></p>
<p>后来研究者根据 <strong>CPU</strong>的运行级别，分成了Ring0~Ring3四个级别。Ring0是最高级别，Ring1次之，Rng2更次之，拿Linux+x86来说，  操作系统内核的代码运行在最高运行级别Ring0上，可以使用特权指令，控制中断、修改页表、访问设备等。 </p>
<p>应用程序的代码运行在最低运行级别上Ring3上，不能做受控操作，只能访问用户被分配的空间。如果要做访问磁盘跟写文件等操作，那就要通过执行系统调用函数，执行系统调用的时候，CPU的运行级别会发生从Ring3到Ring0的切换，并跳转到系统调用对应的内核代码位置执行，这样内核就为你完成了设备访问，完成之后再从Ring0返回Ring3。</p>
<p>这个过程也称作 <strong>用户态和内核态的切换</strong>。</p>
<p>用户态想要使用计算机设备或IO需通过系统调用完成sys call，系统调用就是让内核来做这些操作。</p>
<p>而系统调用是影响整个当前进程上下文的，ＣＰＵ提供了个软中断来是实现保护线程，获取系统调用号跟参数，交给内核对应系统调用函数执行。</p>
<p><img src="img/41de6aee-aa83-4e70-8d7c-43293ba3103b.png" alt="img"></p>
<p>​                                                                        Linux系统结构</p>
<p>可以看到每个应用程序都各自有独立的虚拟内存地址，但每个虚拟内存中对应的内核地址其实是相同的一大块，这样当进程切换到内核态后可以很方便地访问内核空间内存。比如Java代码创建线程 <code>new Thread</code>调用 <code>start</code>方法后跟踪 <code>JVM</code>源码你会发现是调用 <code>pthread_create</code>来创建线程的，这就涉及到了用户态到内核态的切换。</p>
<h4 id="3-2-进程管理"><a href="#3-2-进程管理" class="headerlink" title="3.2. 进程管理"></a>3.2. 进程管理</h4><h5 id="3-2-1-进程基础知识"><a href="#3-2-1-进程基础知识" class="headerlink" title="3.2.1 进程基础知识"></a>3.2.1 进程基础知识</h5><p>进程是程序的一次执行，是一个程序及其数据在机器上顺序执行时所发生的活动，是具有独立功能的程序在一个数据集合上的一次运行过程，是系统进行资源分配和调度的一个基本单位。进程的调度状态如下：</p>
<p><img src="img/20b227b3-31f8-45e1-80fc-33a6ec4513c7.png" alt="img"></p>
<p>​                                                                                            状态变化图</p>
<p>重点说下 <code>挂起</code>跟 <code>阻塞</code>：</p>
<ol>
<li>阻塞一般是当系统执行IO操作时，此时进程进入阻塞状态，等待某个事件的返回。</li>
<li>挂起是指进程没有占有物理内存，被写到磁盘上了。这时进程状态是挂起状态。</li>
</ol>
<blockquote>
<ol>
<li><code>阻塞挂起</code>：进程被写入硬盘并等待某个事件的出现。</li>
<li><code>就绪挂起</code>：进程被写入硬盘，进入内存可直接进入就绪状态。</li>
</ol>
</blockquote>
<h5 id="3-2-2-PCB"><a href="#3-2-2-PCB" class="headerlink" title="3.2.2 PCB"></a>3.2.2 PCB</h5><p>为了描述跟控制进程的运行，系统为每个进程定义了一个数据结构——<code>进程控制块 Process Control Block</code>，它是进程实体的一部分，是操作系统中最重要的记录型数据结构。</p>
<p>PCB 的作用是<strong>使一个在多道程序环境下不能独立运行的程序，成为一个能独立运行的基本单位，一个能与其它进程并发执行的进程</strong> :</p>
<ol>
<li>作为独立运行基本单位的标志</li>
<li>实现间断性的运行方式</li>
<li>提供进程管理所需要的信息</li>
<li>提供进程调度所需要的信息</li>
<li>实现与其他进程的同步与通信</li>
</ol>
<h6 id="3-2-2-1-PCB-信息"><a href="#3-2-2-1-PCB-信息" class="headerlink" title="3.2.2.1 PCB 信息"></a>3.2.2.1 PCB 信息</h6><p>PCB为实现上述功能，内部包含众多信息：</p>
<ol>
<li><strong>进程标识符</strong>：用于唯一地标识一个进程，一个进程通常有两种标识符：</li>
</ol>
<blockquote>
<ol>
<li><code>内部进程标识符</code>：标识各个进程，每个进程都有一个并且唯一的标识符，设置内部标识符主要是为了方便系统使用。</li>
<li><code>外部进程标识符</code>：它由创建者提供，可设置用户标识，以指示拥有该进程的用户。往往是由用户进程在访问该进程时使用。一般为了描述进程的家族关系，还应设置父进程标识及子进程标识。</li>
</ol>
</blockquote>
<ol start="2">
<li><strong>处理机状态</strong>：由各种寄存器组成。包含许多信息都放在寄存器中，方便程序restart。</li>
</ol>
<blockquote>
<ol>
<li>通用寄存器、指令计数器、程序状态字PSW、用户栈指针等信息。</li>
</ol>
</blockquote>
<ol start="3">
<li><strong>进程调度信息</strong></li>
</ol>
<blockquote>
<ol>
<li>进程状态：指明进程的当前状态，作为进程调度和对换时的依据。</li>
<li>进程优先级：用于描述进程使用处理机的优先级别的一个整数，优先级高的进程应优先获得处理机</li>
<li>进程调度所需的其它信息：与所采用的进程调度算法有关，如进程已等待CPU的时间总和、进程已执行的时间总和等。</li>
<li>事件：指进程由执行状态转变为阻塞状态所等待发生的事件，即阻塞原因。</li>
</ol>
</blockquote>
<ol start="4">
<li><strong>资源清单</strong></li>
</ol>
<blockquote>
<p>有关内存地址空间或虚拟地址空间的信息，所打开文件的列表和所使用的 I/O 设备信息。</p>
</blockquote>
<h6 id="3-2-2-2-PCB-组织方式"><a href="#3-2-2-2-PCB-组织方式" class="headerlink" title="3.2.2.2 PCB 组织方式"></a>3.2.2.2 PCB 组织方式</h6><p>操作系统中有太多 PCB，如何管理是个问题，一般有如下方式。</p>
<p>​                                                                                        </p>
<ol>
<li><strong>线性方式</strong>：</li>
</ol>
<blockquote>
<ol>
<li>将系统所有PCB都组织在一张线性表中，将该表首地址存在内存的一个专用区域</li>
<li>实现简单，开销小，但是每次都需要扫描整张表，适合进程数目不多的系统</li>
</ol>
</blockquote>
<p><img src="img/87e5c81b-3286-43b3-b8f9-48f8096185a3.png" alt="img"></p>
<p>​                                                                            线性数组</p>
<p>​                                                                                </p>
<ol start="2">
<li><strong>索引方式</strong>：</li>
</ol>
<blockquote>
<ol>
<li>将同一状态的进程组织在一个索引表中，索引表项指向相应的 PCB，不同状态对应不同的索引表。</li>
</ol>
</blockquote>
<p><img src="img/5b023eff-271f-4e49-9876-ac43e369b65b.png" alt="img"></p>
<p>​                                                                                索引方式</p>
<p>​                                                                                        </p>
<ol start="3">
<li><strong>链接方式</strong>：</li>
</ol>
<blockquote>
<ol>
<li>把同一状态的PCB链接成一个队列，形成就绪队列、阻塞队列、空白队列等。对其中的就绪队列常按进程优先级的高低排列，优先级高排在队前。</li>
<li>因为进程创建、销毁、调度频繁，所以<strong>一般采用此模式</strong>。</li>
</ol>
</blockquote>
<p><img src="img/3f5b2ea5-53a7-4265-9528-fec5e7d20360.png" alt="img"></p>
<p>​                                                                            链表方式</p>
<h5 id="3-2-3-进程控制"><a href="#3-2-3-进程控制" class="headerlink" title="3.2.3 进程控制"></a>3.2.3 进程控制</h5><p>进程控制是进程管理最基本的功能，主要包括<code>创建新进程</code>，<code>终止已完成的进程</code>，<code>将发生异常的进程置于阻塞状态</code>，<code>将进程唤醒</code>等。</p>
<h6 id="3-2-3-1-进程创建"><a href="#3-2-3-1-进程创建" class="headerlink" title="3.2.3.1 进程创建"></a>3.2.3.1 进程创建</h6><p>父进程可创建子进程，父进程终止后子进程也会被终止。子进程可继承父进程所有资源，子进程终止需将自己所继承的资源归还父进程。接下来看下创建的大致流程。</p>
<ol>
<li>为新进程分配唯一进件标识号，然后创建一个空白PCB，需注意PCB数量是有限的，所以可能会创建失败。</li>
<li>尝试为新进程分配所需资源，如果资源不足进程会进入等待状态。</li>
<li>初始化PCB，有如下几个操作。</li>
</ol>
<blockquote>
<ol>
<li>标识信息：将系统分配的标识符和父进程标识符填入新PCB</li>
<li>处理机状态信息：使程序计数器指向程序入口地址，使栈指针指向栈顶</li>
<li>处理机控制信息：将进程设为就绪/静止状态，通常设为最低优先级</li>
</ol>
</blockquote>
<ol>
<li>如果进程调度队列能接纳新进程，就将进程插入到就绪队列，等待被调度运行。</li>
</ol>
<h6 id="3-2-3-2-进程终止"><a href="#3-2-3-2-进程终止" class="headerlink" title="3.2.3.2 进程终止"></a>3.2.3.2 进程终止</h6><p>进程终止情况一般分为正常结束、异常结束、外界干预三种。</p>
<ol>
<li>正常结束</li>
<li>异常结束</li>
</ol>
<blockquote>
<ol>
<li>越界错：访问的存储区越出该进程的区域</li>
<li>保护错：试图访问不允许访问的资源，或以不适当的方式访问（写只读）</li>
<li>非法指令：试图执行不存在的指令（可能是程序错误地转移到数据区，数据当成了指令）</li>
<li>特权指令出错：用户进程试图执行一条只允许OS执行的指令</li>
<li>运行超时：执行时间超过指定的最大值</li>
<li>等待超时：进程等待某件事超过指定的最大值</li>
<li>算数运算错：试图执行被禁止的运算（被0除）</li>
<li>I/O故障</li>
</ol>
</blockquote>
<ol start="3">
<li>外界干预</li>
</ol>
<blockquote>
<ol>
<li>操作员或OS干预（死锁）</li>
<li>父进程请求，子进程完成父进程指定的任务时</li>
<li>父进程终止，所有子进程都应该结束</li>
</ol>
</blockquote>
<p><strong>终止过程</strong>：</p>
<ol>
<li>根据被终止进程的标识符，从PCB集合中检索出该PCB，读取进程状态</li>
<li>若处于执行状态则立即终止执行，将CPU资源分配给其他进程。</li>
<li>若进程有子孙进程则将其所有子孙进程终止。</li>
<li>全部资源还给父进程或操作系统。</li>
<li>该进程的PCB从所在队列/链表中移出。</li>
</ol>
<h6 id="3-2-3-3-进程阻塞"><a href="#3-2-3-3-进程阻塞" class="headerlink" title="3.2.3.3 进程阻塞"></a>3.2.3.3 进程阻塞</h6><p>意思是该进程执行半路被阻塞，必须由某个事件进程唤醒该进程。常见的就是IO读取操作。常见阻塞时机/事件如下：</p>
<ol>
<li>请求共享资源失败，系统无足够资源分配</li>
<li>等待某种操作完成</li>
<li>新数据尚未到达（相互合作的进程）</li>
<li>等待新任务</li>
</ol>
<p><strong>阻塞流程</strong>：</p>
<ol>
<li>找到要被阻塞进程标识号对应的 PCB。</li>
<li>将该进程由运行状态转换为阻塞状态。</li>
<li>将该 进程PCB 插入的阻塞队列中去。</li>
</ol>
<h6 id="3-2-3-4-进程唤醒"><a href="#3-2-3-4-进程唤醒" class="headerlink" title="3.2.3.4 进程唤醒"></a>3.2.3.4 进程唤醒</h6><p>唤醒 原语 wake up，一般和阻塞成对使用。唤醒过程如下：</p>
<ol>
<li>从阻塞队列找到所需PCB。</li>
<li>PCB从阻塞队列溢出，然后变为就绪状态。</li>
<li>从阻塞队列溢出该PCB然后插入到就绪状态队列等待被分配CPU资源。</li>
</ol>
<h5 id="3-2-4-进程调度"><a href="#3-2-4-进程调度" class="headerlink" title="3.2.4 进程调度"></a>3.2.4 进程调度</h5><p>进程数一般会大于CPU个数，进程状态切换主要由调度程序进行调度。一般情况下CPU调度时主要分为<code>抢占式调度</code>跟<code>非抢占式调度</code>。</p>
<ol>
<li><code>非抢占式</code>：让进程运行直到结束或阻塞的调度方式， 容易实现，适合专用系统。</li>
<li><code>抢占式</code>：每个进程获得时间片才可以被CPU调度运行， 可防止单一进程长时间独占CPU 系统开销大。</li>
</ol>
<h6 id="3-2-4-1-进程调度原则"><a href="#3-2-4-1-进程调度原则" class="headerlink" title="3.2.4.1 进程调度原则"></a>3.2.4.1 进程调度原则</h6><ol>
<li><strong>CPU 利用率</strong></li>
</ol>
<blockquote>
<ol>
<li>CPU利用率 = 忙碌时间 / 总时间。</li>
<li>调度程序应该尽量让 CPU 始终处于忙碌的状态，这可提高 CPU 的利用率。比如当发生IO读取时候，不要傻傻等待，去执行下别的进程。</li>
</ol>
</blockquote>
<ol start="2">
<li><strong>系统吞吐量</strong></li>
</ol>
<blockquote>
<ol>
<li>系统吞吐量 = 总共完成多少个作业 / 总共花费时间。</li>
<li>长作业的进程会占用较长的 CPU 资源导致降低吞吐量，相反短作业的进程会提升系统吞吐量。</li>
</ol>
</blockquote>
<ol start="3">
<li><strong>周转时间</strong></li>
</ol>
<blockquote>
<ol>
<li>周转时间 = 作业完成时间 - 作业提交时间。</li>
<li>平均周转时间 = 各作业周转时间和 / 作业数</li>
<li>带权周转时间 = 作业周转时间 / 作业实际运行时间</li>
<li>平均带权周转时间 = 各作业带权周转时间之和 / 作业数</li>
<li>尽可能使周转时间降低。</li>
</ol>
</blockquote>
<ol start="4">
<li><strong>等待时间</strong></li>
</ol>
<blockquote>
<ol>
<li>指的是进程在等待队列中等待的时间，一般也需要尽可能短。</li>
<li><strong>响应时间</strong><br>响应时间 = 系统第一次响应时间 - 用户提交时间，在交互式系统中响应时间是衡量调度算法好坏的主要标准。</li>
</ol>
</blockquote>
<h6 id="3-2-4-2-调度算法"><a href="#3-2-4-2-调度算法" class="headerlink" title="3.2.4.2 调度算法"></a>3.2.4.2 调度算法</h6><p><strong>FCFS 算法</strong></p>
<ol>
<li>First Come First Severd 先来先服务算法，遵循先来后端原则，每次从就绪队列拿等待时间最久的，运行完毕后再拿下一个。</li>
<li>该模式对长作业有利，适用 CPU 繁忙型作业的系统，不适用 I/O 型作业，因为会导致进程CPU利用率很低。</li>
</ol>
<p><strong>SJF 算法</strong></p>
<ol>
<li>Shortest Job First 最短作业优先算法，该算法会优先选择运行所需时间最短的进程执行，可提高吞吐量。</li>
<li>跟FCFS正好相反，对长作业很不利。</li>
</ol>
<p><strong>SRTN 算法</strong></p>
<ol>
<li>Shortest Remaining Time Next 最短剩余时间优先算法，可以认为是SJF的抢占式版本，当一个新就绪的进程比当前运行进程具有更短完成时间时，系统抢占当前进程，选择新就绪的进程执行。</li>
<li>有最短的平均周转时间，但不公平，源源不断的短任务到来，可能使长的任务长时间得不到运行。</li>
</ol>
<p><strong>HRRN 算法</strong></p>
<ol>
<li>Highest Response Ratio Next 最高响应比优先算法，为了平衡前面俩而生，按照响应优先权从高到低依次执行。属于前面俩的折中权衡。</li>
<li>优先权 = (等待时间 + 要求服务时间) / 要求服务时间</li>
</ol>
<p><strong>RR 算法</strong></p>
<ol>
<li>Round Robin 时间片轮转算法，操作系统设定了个时间片Quantum，时间片导致每个进程只有在该时间片内才可以运行，这种方式导致每个进程都会均匀的获得执行权。</li>
<li>时间片一般20ms~50ms，如果太小会导致系统频繁进行上下文切换，太大又可能引起对短的交互请求的响应变差。</li>
</ol>
<p><strong>HPF 算法</strong></p>
<ol>
<li>Highest Priority First 最高优先级调度算法，从就绪队列中选择最高优先级的进程先执行。</li>
<li>优先级的设置有初始化固定死的那种，也有在代码运转过程中根据等待时间或性能动态调整 这两种思路。</li>
<li>缺点是可能导致低优先级的一直无法被执行。</li>
</ol>
<p><strong>MFQ 算法</strong></p>
<ol>
<li><p>Multilevel Feedback Queue 多级反馈队列调度算法 ，可以认为是 RR 算法 跟 HPF 算法 的综合体。</p>
</li>
<li><p>系统会同时存在多个就绪队列，每个队列优先级从高到低排列，同时优先级越高获得是时间片越短。</p>
</li>
<li><p>新进程会先加入到最高优先级队列，如果新进程优先级高于当前在执行的进程，会停止当前进程转而去执行新进程。新进程如果在时间片内没执行完毕需下移到次优先级队列。</p>
<p><img src="img/91590ac0-8bf1-47ec-bee1-0e7a979b1ac5.png" alt="img"></p>
<p>​                                                                多级反馈队列调度算法</p>
</li>
</ol>
<h5 id="3-2-5-线程"><a href="#3-2-5-线程" class="headerlink" title="3.2.5 线程"></a>3.2.5 线程</h5><h6 id="3-2-5-1-线程定义"><a href="#3-2-5-1-线程定义" class="headerlink" title="3.2.5.1 线程定义"></a>3.2.5.1 线程定义</h6><p>早期操作系统是没有线程概念的，线程是后来加进来的。为啥会有线程呢？那是因为以前在多进程阶段，经常会涉及到进程之间如何通讯，如何共享数据的问题。并且进程关联到PCB的生命周期，管理起来开销较大。为了解决这个问题引入了线程。</p>
<p>线程是进程当中的一个执行流程。同一个进程内的多个线程之间可以共享进程的代码段、数据段、打开的文件等资源。同时每个线程又都有一套独立的寄存器和栈来确保线程的控制流是独立的。</p>
<p>进程有个<code>PCB</code>来管理，同理操作系统通过 <code>Thread Control Block</code>线程控制块来实现线程的管控。</p>
<h6 id="3-2-5-2-线程优缺点"><a href="#3-2-5-2-线程优缺点" class="headerlink" title="3.2.5.2 线程优缺点"></a>3.2.5.2 线程优缺点</h6><p><strong>优点</strong></p>
<ol>
<li>一个进程中可以同时存在1~N个线程，这些线程可以并发的执行。</li>
<li>各个线程之间可以共享地址空间和文件等资源。</li>
</ol>
<p><strong>缺点</strong></p>
<ol>
<li>当进程中的一个线程奔溃时，会导致其所属进程的所有线程奔溃。</li>
<li>多线程编程，让人头大的东西。</li>
<li>线程执行开销小，但不利于资源的隔离管理和保护，而进程正相反。</li>
</ol>
<h6 id="3-2-5-3-进程跟线程关联"><a href="#3-2-5-3-进程跟线程关联" class="headerlink" title="3.2.5.3 进程跟线程关联"></a>3.2.5.3 进程跟线程关联</h6><p><strong>进程</strong>：</p>
<ol>
<li>是系统进行资源分配和调度的一个独立单位.</li>
<li>是程序的一次执行，每个进程都有自己的地址空间、内存、数据栈及其他辅助记录运行轨迹的数据</li>
</ol>
<p><strong>线程</strong>：</p>
<ol>
<li>是进程的一个实体，是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位</li>
<li>所有的线程运行在同一个进程中，共享相同的运行资源和环境</li>
<li>线程一般是并发执行的，使得实现了多任务的并行和数据共享。</li>
</ol>
<p><strong>进程线程区别</strong>：</p>
<ol>
<li>一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。</li>
<li>线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。</li>
<li>进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。</li>
<li>资源分配给进程，同一进程的所有线程共享该进程的所有资源。</li>
<li>CPU分配资源给进程，但真正在CPU上运行的是线程。</li>
<li>线程不能够独立执行，必须依存在进程中。</li>
</ol>
<p><strong>线程快在哪儿</strong>？</p>
<ol>
<li>线程创建的时有些资源不需要自己管理，直接从进程拿即可，线程管理寄存器跟栈的生命周期即可。</li>
<li>同进程内多线程共享数据，所以进程数据传输可以用zero copy技术，不需要经过内核了。</li>
<li>进程使用一个虚拟内存跟页表，然后多线程共用这些虚拟内存，如果同进程内两个线程进行上下文切换比进程提速很多。</li>
</ol>
<h6 id="3-2-5-4-线程实现"><a href="#3-2-5-4-线程实现" class="headerlink" title="3.2.5.4 线程实现"></a>3.2.5.4 线程实现</h6><p>在前面的内存管理中说到了内核态跟用户态。相对应的线程的创建也分为<code>用户态线程</code>跟<code>内核态线程</code>。</p>
<p>3.2.5.4.1 <strong>用户态线程</strong></p>
<p>在用户空间实现的线程，由用户态的线程库来完成线程的管理。操作系统按进程维度进行调度，<strong>当线程在用户态创建时应用程序在用户空间内要实现线程的创建、维护和调度。操作系统对线程的存在一无所知</strong>！操作系统只能看到进程看不到线程。所有的线程都是在用户空间实现。在操作系统看来，每一个进程只有一个线程。</p>
<p><img src="img/fd745884-8b80-4073-9b4e-749b74a68b6c.png" alt="img"></p>
<p>​                                                                                        用户态线程</p>
<p><strong>好处</strong>：</p>
<ol>
<li>即使操作系统不支持线程模式也可以通过用户层库函数来支持线程模式，TCB 由用户级线程库函数来维护。</li>
<li>使用库函数模式实现线程可以避免用户态到内核态的切换。</li>
</ol>
<p><strong>坏处</strong>：</p>
<ol>
<li><p>CPU不知道线程存在，CPU的时间片切换是以进程为维度的，某个线程因为IO等操作导致线程阻塞，操作系统会阻塞整个进程，即使这个进程中其它线程还在工作。</p>
</li>
<li><p>用户态线程没法打断正在运行中的线程，除非线程主动交出CPU使用权。</p>
</li>
</ol>
<p>3.2.5.4.2 <strong>内核态线程</strong></p>
<p>在内核中实现的线程，是由内核管理的线程，线程对应的 TCB 在操作系统里，这样线程的创建、终止和管理都是由操作系统负责。内线程模式下一个用户线程对应一个内核线程。</p>
<p><img src="img/879df359-f048-4f0c-b228-85dcae225388.png" alt="img"></p>
<p>​                                                                            内核态线程</p>
<p><strong>注意</strong>：Linux中的JVM从1.2版以后是基于pthread实现的， <code>所以现在Java中线程的本质就是操作系统中的线程</code>。</p>
<p><strong>优点</strong>：</p>
<ol>
<li>一个进程中某个线程阻塞不会影响其他内核线程运行。</li>
<li>用户态模式一个时间片分给多个线程，内核态模式直接分配给线程的时间片增加。</li>
</ol>
<p><strong>缺点</strong>：</p>
<ol>
<li><p>内核级线程调度开销较大。调度内核线程的代价可能和调度进程差不多昂贵，代价要比用户级线程大很多。一个线程默认栈=1M，线程多了会导致内存消耗很大。</p>
</li>
<li><p>线程表是存放在操作系统固定的表格空间或者堆栈空间里，所以内核级线程的数量是有限的。</p>
</li>
</ol>
<p>3.2.5.4.3 <strong>轻量级进程</strong></p>
<p>最初的进程定义都包含程序、资源及其执行三部分，其中程序通常指代码，资源在操作系统层面上通常包括内存资源、IO资源、信号处理等部分，而程序的执行通常理解为执行上下文，包括对CPU的占用，后来发展为线程。在线程概念出现以前，为了减小进程切换的开销，操作系统设计者逐渐修正进程的概念，逐渐允许将进程所占有的资源从其主体剥离出来，允许某些进程共享一部分资源，例如文件、信号，数据内存，甚至代码，这就发展出轻量进程的概念。</p>
<p>Light-weight process <strong>轻量级进程是内核支持的用户线程</strong>，它是基于内核线程的高级抽象，系统只有先支持内核线程才能有 LWP。一个进程可有1~N个LWP，每个 LWP 是跟内核线程一对一映射的，也就是 LWP 都是由一个内核线程支持。</p>
<p><img src="img/2cd8e3b4-fd60-432f-9865-9c7a27c208e4.png" alt="img"></p>
<p>​                                                                                            LWP模式</p>
<p><strong>轻量级进程本质还是进程</strong>，只是跟普通进程相比LWP跟其他进程共享大部分逻辑地址空间跟系统资源，LWP轻量体现在它只有一个最小的执行上下文和调度程序所需的统计信息。他是进程的执行部分，只带有执行相关的信息。</p>
<p><strong>Linux特性</strong>：</p>
<ol>
<li>Linux中没有真正的线程，因为Linux并没有为线程准备特定的数据结构。在内核看来只有进程而没有线程，在调度时也是当做进程来调度。Linux所谓的线程其实是与其他进程共享资源的进程。但windows中确实有线程。</li>
<li>Linux中没有的线程，线程是由进程来模拟实现的。</li>
<li>所以在Linux中在CPU角度看，进程被称作轻量级进程LWP。</li>
</ol>
<h6 id="3-2-5-5-协程"><a href="#3-2-5-5-协程" class="headerlink" title="3.2.5.5 协程"></a>3.2.5.5 协程</h6><ol>
<li><strong>协程定义</strong></li>
</ol>
<p>大多数web服务跟互联网服务本质上大部分都是 IO 密集型服务，IO 密集型服务的瓶颈不在CPU处理速度，而在于尽可能快速的完成高并发、多连接下的数据读写。以前有两种解决方案：</p>
<ol>
<li><code>多进程</code>：存在频繁调度切换问题，同时还会存在每个进程资源不共享的问题，需要额外引入进程间通信机制来解决。</li>
<li><code>多线程</code>：高并发场景的大量 IO 等待会导致多线程被频繁挂起和切换，非常消耗系统资源，同时多线程访问共享资源存在竞争问题。</li>
</ol>
<p>此时协程出现了，协程 Coroutines 是一种比线程更加轻量级的微线程。类比一个进程可以拥有多个线程，一个线程也可以拥有多个协程。可以简单的把协程理解成子程序调用，每个子程序都可以在一个单独的协程内执行。</p>
<p><img src="img/816437f6-bc2f-47f3-931f-4a576894f42f.png" alt="img"></p>
<p>​                                                                                            协程</p>
<p>协程运行在线程之上，当一个协程执行完成后，可以选择主动让出，让另一个协程运行在当前线程之上。 <strong>协程并没有增加线程数量，只是在线程的基础之上通过分时复用的方式运行多个协程</strong>，而且协程的切换在用户态完成，切换的代价比线程从用户态到内核态的代价小很多，一般在Python、Go中会涉及到协程的知识，尤其是现在高性能的脚本Go。</p>
<ol start="2">
<li><strong>协程注意事项</strong></li>
</ol>
<p>协程运行在线程之上，并且协程调用了一个阻塞IO操作，此时操作系统并不知道协程的存在，它只知道线程，因此在协程调用阻塞IO操作时，操作系统会让线程进入阻塞状态，当前的协程和其它绑定在该线程之上的协程都会陷入阻塞而得不到调度。</p>
<p>因此在协程中不能调用导致线程阻塞的操作，比如打印、读取文件、Socket接口等。<code>协程只有和异步IO结合</code>起来才能发挥最大的威力。并且<strong>协程只有在IO密集型的任务中才会发挥作用</strong>。</p>
<h5 id="3-2-6-进程通信"><a href="#3-2-6-进程通信" class="headerlink" title="3.2.6 进程通信"></a>3.2.6 进程通信</h5><p>进程的用户地址空间是相互独立的，不可以互相访问，但内核空间是进程都共享的，所以进程之间要通信必须通过内核。<strong>进程间通信主要通过管道、消息队列、共享内存、信号量、信号、Socket编程</strong>。</p>
<h6 id="3-2-6-1-管道"><a href="#3-2-6-1-管道" class="headerlink" title="3.2.6.1 管道"></a>3.2.6.1 管道</h6><p>管道主要分为匿名管道跟命名管道两种，可以实现数据的单向流动性。<strong>使用起来很简单，但是管道这种通信方式效率低，不适合进程间频繁地交换数据</strong>。</p>
<p><strong>匿名管道</strong>：</p>
<ol>
<li>日常Linux系统中的<code>|</code>就是匿名管道。指令的前一个输入是后一个指令的输出。</li>
</ol>
<p><strong>命名管道</strong>：</p>
<ol>
<li>一般通过<code>mkfifo SoWhatPipe</code>创建管道。通过<code>echo &quot;sw&quot; &gt; SoWhatPipe</code>跟<code>cat &lt; SoWhatPipe</code> 实现输入跟输出。</li>
</ol>
<p>匿名管道的实现依赖<code>int pipe(int fd[2])</code>函数，其中<code>fd[0]</code>是读取端描述符，<code>fd[1]</code>是管道写入端描述符。它的本质就是在内核中创建个属于内存的缓存，从一端输入无格式数据一端输出无格式数据，需注意管道传输大小是有限的。</p>
<p><img src="img/c648cd69-ef8d-492a-951f-468ce8bc4734.png" alt="img"></p>
<p>​                                                                                管道通信底层</p>
<p>匿名管道的通信范围是存在父子关系的进程。由于管道没有实体，也就是没有管道文件，不会涉及到文件系统。只能通过 <code>fork</code>子进程来复制父进程 fd 文件描述符，父子进程通过共用特殊的管道文件实现跨进程通信，并且因为管道只能一端写入，另一端读出，所以通常父子进程遵从如下要求：</p>
<ol>
<li>父进程关闭读取的 fd[0]，只保留写入的 fd[1]。</li>
<li>子进程关闭写入的 fd[1]，只保留读取的 fd[0]。</li>
</ol>
<p><img src="img/dd93aa6f-ecea-40b5-8be8-d26f28b3b89c.png" alt="img"></p>
<p>​                                                                                    shell管道通信</p>
<p>需注意Shell执行匿名管道 a | b其实是通过Shell父进程fork出了两个子进程来实现通信的，而ab之间是不存在父子进程关系的。而命名管道是可以直接在不相关进程间通信的，因为有管道文件。</p>
<h6 id="3-2-6-2-消息队列"><a href="#3-2-6-2-消息队列" class="headerlink" title="3.2.6.2 消息队列"></a>3.2.6.2 消息队列</h6><p><img src="img/4519903d-0d1f-4dbb-8bcb-766e0858ab10.png" alt="img"></p>
<p>​                                                                                            消息队列</p>
<p>消息队列是保存在 <strong>内核</strong>中的消息链表， <strong>会涉及到用户态跟内核态到来回切换</strong>，双方约定好消息体到数据结构，然后发送数据时将数据分成一个个独立的数据单元消息体，需注意消息队列及单个消息都有上限，日常我们到 <a target="_blank" rel="noopener" href="https://www.oschina.net/action/GoToLink?url=http://mp.weixin.qq.com/s?__biz=MzI4NjI1OTI4Nw==&mid=2247490325&idx=1&sn=ab7cfedc7b8f2361cc1fab9418b314b8&chksm=ebdefa2ddca9733b76cffbcba2d5f8c0c61bd36d5ebba20aaecb07148aa0fd7a5781e16ab03e&scene=21%23wechat_redirect">RabbitMQ</a>、 <a target="_blank" rel="noopener" href="https://www.oschina.net/action/GoToLink?url=http://mp.weixin.qq.com/s?__biz=MzI4NjI1OTI4Nw==&mid=2247488832&idx=1&sn=5999893d7fe773f54f7d097ac1c2074d&chksm=ebdef478dca97d6e2433abdeecf600669ffbb1b68eb2b744e7ed72aac4cd5c4cabf19b0d8f19&scene=21%23wechat_redirect">Redis </a>都涉及到消息队列。</p>
<h6 id="3-2-6-3-共享内存"><a href="#3-2-6-3-共享内存" class="headerlink" title="3.2.6.3 共享内存"></a>3.2.6.3 共享内存</h6><p><img src="img/8742cdfb-d23e-4c93-899a-0b0c61e7d738.png" alt="img"></p>
<p>​                                                                                            共享空间</p>
<p>现代操作系统对内存管理采用的是虚拟内存技术，也就是每个进程都有自己独立的虚拟内存空间，不同进程的虚拟内存映射到不同的物理内存中。所以，即使进程A和进程B虚拟地址是一样的，真正访问的也是不同的物理内存地址，该模式不涉及到用户态跟内核态来回切换，JVM 就是用的共享内存模式。并且并发编程也是个难点。</p>
<h6 id="3-2-6-4-信号量"><a href="#3-2-6-4-信号量" class="headerlink" title="3.2.6.4 信号量"></a>3.2.6.4 信号量</h6><p>既然共享内存容易造成数据紊乱，那为了简单的实现共享数据在任意时刻只能被一个进程访问，此时需要信号量。</p>
<p><strong>信号量其实是一个整型的计数器，主要用于实现进程间的互斥与同步，而不是用于缓存进程间通信的数据</strong>。</p>
<p>信号量表示资源的数量，核心点在于原子性的控制一个数据的值，控制信号量的方式有<strong>PV两种原子操作</strong>：</p>
<ol>
<li>P 操作会把信号量减去 -1，相减后如果信号量 &lt; 0，则表明资源已被占用，进程需阻塞等待。相减后如果信号量 &gt;= 0，则表明还有资源可使用，进程可正常继续执行。</li>
<li>V 操作会把信号量加上 1，相加后如果信号量 &lt;= 0，则表明当前有阻塞中的进程，于是会将该进程唤醒运行。相加后如果信号量 &gt; 0，则表明当前没有阻塞中的进程。</li>
</ol>
<h6 id="3-2-6-5-信号"><a href="#3-2-6-5-信号" class="headerlink" title="3.2.6.5 信号"></a>3.2.6.5 信号</h6><p>对于异常状态下进程工作模式需要用到信号工作方式来通知进程。比如Linux系统为了响应各种事件提供了很多异常信号<code>kill -l</code>，<strong>信号是进程间通信机制中唯一的异步通信机制</strong>，可以在任何时候发送信号给某一进程。比如：</p>
<ol>
<li>kill -9 1412 ，表示给 PID 为 1412 的进程发送 SIGKILL 信号，用来立即结束该进程。</li>
<li>键盘 Ctrl+C 产生 SIGINT 信号，表示终止该进程。</li>
<li>键盘 Ctrl+Z 产生 SIGTSTP 信号，表示停止该进程，但还未结束。</li>
</ol>
<p>有信号发生时，进程一般有三种方式响应信号：</p>
<ol>
<li>执行默认操作：Linux操作系统为众多信号配备了专门的处理操作。</li>
<li>捕捉信号：给捕捉到的信号配备专门的信号处理函数。</li>
<li>忽略信号：专门用来忽略某些信号，但 SIGKILL 和 SEGSTOP是无法被忽略的，为了能在任何时候结束或停止某个进程而存在。</li>
</ol>
<h6 id="3-2-6-6-Socket编程"><a href="#3-2-6-6-Socket编程" class="headerlink" title="3.2.6.6 Socket编程"></a>3.2.6.6 Socket编程</h6><p>前面提到的管道、消息队列、共享内存、信号量和信号都是在同一台主机上进行进程间通信，<strong>那要想跨网络与不同主机上的进程之间通信，就需要 Socket 通信</strong>。</p>
<pre class="line-numbers language-none"><code class="language-none">int socket(int domain, int type, int protocal)<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre>

<p>上面是socket编程的核心函数，可以指定IPV4或IPV6类型，TCP或UDP类型。比如<a target="_blank" rel="noopener" href="https://www.oschina.net/action/GoToLink?url=http://mp.weixin.qq.com/s?__biz=MzI4NjI1OTI4Nw==&mid=2247490719&idx=1&sn=9590fea26b75698ddb37b24ef34e0c8c&chksm=ebdefda7dca974b16ac1e3ae78ff0222c4ad4bd181a70a233df8683cb3fb6199395e14bd65e6&scene=21%23wechat_redirect"><strong>TCP</strong></a>协议通信的 socket 编程模型如下：</p>
<p><img src="img/96765c91-cfde-41f6-b0a7-4297e5db1dec.png" alt="img"></p>
<p>Socket编程</p>
<ol>
<li>服务端和客户端初始化 <code>socket</code>，得到文件描述符。</li>
<li>服务端调用<code>bind</code>，将绑定在 IP 地址和端口。</li>
<li>服务端调用 <code>listen</code>，进行监听。</li>
<li>服务端调用 <code>accept</code>，等待客户端连接。</li>
<li>客户端调用 <code>connect</code>，向服务器端的地址和端口发起连接请求。</li>
<li>服务端 <code>accept</code> 返回用于传输的 <code>socket</code> 的文件描述符。</li>
<li>客户端调用 <code>write</code> 写入数据，服务端调用 <code>read</code> 读取数据。</li>
<li>客户端断开连接时，会调用 <code>close</code>，那么服务端 <code>read</code> 读取数据的时候，就会读取到了<code>EOF</code>，待处理完数据后，服务端调用 close，表示连接关闭。</li>
<li>服务端调用 <code>accept</code>时，连接成功会返回一个已完成连接的 <code>socket</code>，后续用来传输数据。服务端有俩<code>socket</code>，一个叫作监听 <code>socket</code>，一个叫作已完成连接 <code>socket</code>。</li>
<li>成功连接建立之后双方开始通过 read 和 write 函数来读写数据。</li>
</ol>
<p><img src="img/801407b6-2254-4817-ac01-a40b6ce01bdb.png" alt="img"></p>
<p>​                                                                                            UDP传输</p>
<p>UDP比较简单，属于类似广播性质的传输，不需要维护连接。但也需要 bind，每次通信时调用 sendto 和 recvfrom 都要传入目标主机的 IP 地址和端口。</p>
<h4 id="3-3-文件管理"><a href="#3-3-文件管理" class="headerlink" title="3.3 文件管理"></a>3.3 文件管理</h4><h5 id="3-3-1-VFS-虚拟文件系统"><a href="#3-3-1-VFS-虚拟文件系统" class="headerlink" title="3.3.1  VFS 虚拟文件系统"></a>3.3.1  VFS 虚拟文件系统</h5><p>文件系统在操作系统中主要负责将文件数据信息存储到磁盘中，起到持久化文件的作用。文件系统的基本组成单元就是文件，文件组成方式不同就会形成不同的文件系统。</p>
<p>文件系统有很多种而不同的文件系统应用到操作系统后需要提供统一的对外接口，此时用到了一个设计理念<code>没有什么是加一层解决不了的</code>，在用户层跟不同的文件系统之间加入一个虚拟文件系统层 <code>Virtual File System</code>。</p>
<p>虚拟文件系统层<code>定义了一组所有文件系统都支持的数据结构和标准接口</code>，这样程序员不需要了解文件系统的工作原理，只需要了解 VFS 提供的统一接口即可。</p>
<p><img src="img/0383dbe9-a602-439a-8e9f-43ece8e5d67c.png" alt="img"></p>
<p>​                                                                                虚拟文件系统</p>
<p>日常的文件系统一般有如下三种：</p>
<ol>
<li><code>磁盘文件系统</code>：就是我们常见的EXT 2/3/4系列。</li>
<li><code>内存文件系统</code>：数据没存储到磁盘，占用内存数据，比如<code>/sys</code>、<code>/proc</code>。进程中的一些数据映射到/proc中了。</li>
<li><code>网络文件系统</code>：常见的网盘挂载NFS等，通过访问其他主机数据实现。</li>
</ol>
<h5 id="3-3-2-文件组成"><a href="#3-3-2-文件组成" class="headerlink" title="3.3.2 文件组成"></a>3.3.2 文件组成</h5><p>以Linux系统为例，在Linux系统中一切皆文件，Linux文件系统会为每个文件分配<code>索引节点 inode</code>跟<code>目录项directory entry</code>来记录文件内容跟目录层次结构。</p>
<h6 id="3-3-2-1-inode"><a href="#3-3-2-1-inode" class="headerlink" title="3.3.2.1 inode"></a>3.3.2.1 inode</h6><p>要理解<code>inode</code>要从文件储存说起。文件存储在硬盘上，硬盘的最小存储单位叫做扇区。每个扇区储存512字节。操作系统读取硬盘的时候，不会一个个扇区的读取，这样效率太低，一般一次性连续读取8个扇区(4KB)来当做一块，这种由多个扇区组成的<strong>块</strong>，是文件存取的最小单位。</p>
<p>文件数据都储存在块中，我们还必须找到一个地方储存文件的元信息，比如inode编号、文件大小、创建时间、修改时间、磁盘位置、访问权限等。几乎除了文件名以外的所有文件元数据信息都存储在一个叫叫索引节点inode的地方。可通过<code>stat 文件名</code>查看 inode 信息</p>
<p>每个inode都有一个号码，操作系统用inode号码来识别不同的文件。Unix/Linux系统内部不使用文件名，而使用inode号码来识别文件，用户可通过<code>ls -i</code>查看每个文件对应编号。对于系统来说文件名只是inode号码便于识别的别称或者绰号。特殊名字的文件不好删除时可以尝试用inode号删除，移动跟重命名不会导致文件inode变化，当用户尝试根据文件名打开文件时，实际上系统内部将这个过程分成三步：</p>
<ol>
<li>系统找到这个文件名对应的inode号码。</li>
<li>通过inode号码，获取inode信息，进行权限验证等操作。</li>
<li>根据inode信息，找到文件数据所在的block，读出数据。</li>
</ol>
<p>需注意 inode也会消耗硬盘空间，硬盘格式化后会被分成<strong>超级块</strong>、<strong>索引节点区</strong>和<strong>数据块区</strong>三个区域：</p>
<ol>
<li><p><code>超级块区</code>：用来存储文件系统的详细信息，比如块大小，块个数等信息。一般文件系统挂载后就会将数据信息同步到内存。</p>
</li>
<li><p><code>索引节点区</code>：用来存储索引节点 inode  table。每个inode一般为128字节或256字节，一般每1KB或2KB数据就需设置一个inode。一般为了加速查询会把索引数据缓存到内存。</p>
</li>
<li><p><code>数据块区</code>：真正存储磁盘数据的地方。</p>
<pre class="line-numbers language-none"><code class="language-none">df -i # 查看每个硬盘分区的inode总数和已经使用的数量
sudo dumpe2fs -h &#x2F;dev&#x2F;hda | grep &quot;Inode size&quot; # 查看每个inode节点的大小
sudo xfs_info &#x2F;dev&#x2F;hda # centos7 之后的版本<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span></span></code></pre></li>
</ol>
<h6 id="3-3-2-2-目录"><a href="#3-3-2-2-目录" class="headerlink" title="3.3.2.2 目录"></a>3.3.2.2 目录</h6><p>Unix/Linux系统中<strong>目录directory也是一种文件</strong>，打开目录实际上就是打开目录文件。目录文件内容就是一系列目录项的列，目录项的内容包含<strong>文件的名字、文件类型、索引节点指针以及与其他目录项的层级关系</strong>。</p>
<p>为避免频繁读取磁盘里的目录文件，内核会把已经读过的目录文件用<code>目录项</code>这个数据结构缓存在内存，方便用户下次读取目录信息，目录项可包含目录或文件，不要惊讶于可以保存目录，目录格式的目录项里面保存的是目录里面一项一项的文件信息。</p>
<h6 id="3-3-2-3-软连接跟硬链接"><a href="#3-3-2-3-软连接跟硬链接" class="headerlink" title="3.3.2.3 软连接跟硬链接"></a>3.3.2.3 软连接跟硬链接</h6><p><img src="img/8228db22-9006-4771-9d5b-3693cc21af9d.png" alt="img"></p>
<p>​                                                        软连接跟硬链接</p>
<p><strong>硬链接</strong>：文件A被创建若干个硬链接B、C后。A、B、C三个文件的inode是相同的，所以不能跨文件系统。同时只有ABC全部删除，系统才会删除源文件。<br><strong>软链接</strong>：相当于基于老文件A新建了个文件B，该文件B有新的inode，不过文件B内容是老文件A的路径。所以软链接可以跨文件系统。当老文件A删除后，文件B仍然存在，不过找不到指定文件了。</p>
<pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token punctuation">[</span>coder@localhost ~<span class="token punctuation">]</span>$ <span class="token function">ln</span> <span class="token punctuation">[</span>选项<span class="token punctuation">]</span> 源文件 目标文件
选项：
-s：建立软链接文件。如果不加 <span class="token string">"-s"</span> 选项，则建立硬链接文件；
-f：强制。如果目标文件已经存在，则删除目标文件后再建立链接文件；<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span></span></code></pre>

<h5 id="3-3-3-文件存储"><a href="#3-3-3-文件存储" class="headerlink" title="3.3.3 文件存储"></a>3.3.3 文件存储</h5><p>说文件存储前需了解<strong>文件系统操作基本单位是数据块</strong>，而平常用户操作字节到数据块之间是需要转换的，当然这些文件系统都帮我们对接好了。接下来看文件系统是如何按照数据块进行存储的， 文件在磁盘中存储时候主要分为<code>连续空间存储</code>跟<code>非连续空间存储</code></p>
<h6 id="3-3-3-1-连续空间存储"><a href="#3-3-3-1-连续空间存储" class="headerlink" title="3.3.3.1 连续空间存储"></a>3.3.3.1 连续空间存储</h6><ol>
<li><code>实现</code>：连续空间存储的意思就跟数组存储一样，找个连续的空间一次性把数据存储进去，<strong>文件头</strong>存储起始位置跟数据长度即可。</li>
<li><code>优势</code>：读写效率高，磁盘寻址一次即可。</li>
<li><code>劣势</code>：容易产生空间碎片，并且文件扩容不方便。</li>
</ol>
<p><img src="img/4f402a67-9d80-4a14-a826-2a017076f8c4.png" alt="img"></p>
<p>​                                                                            连续存储</p>
<h6 id="3-3-3-2-非连续空间存储之链表"><a href="#3-3-3-2-非连续空间存储之链表" class="headerlink" title="3.3.3.2 非连续空间存储之链表"></a>3.3.3.2 非连续空间存储之链表</h6><p><strong>隐式链表</strong></p>
<ol>
<li><p><code>实现</code>：文件头包含StartBlock、EndBlock。每个BLock有隐藏的next指针，跟单向链表一样。</p>
</li>
<li><p><code>缺点</code>：只能通过链式不断往下查找数据，不支持快速直接访问。</p>
<p><img src="img/3260adea-7ed2-428d-8230-d4e6c38394a5.png" alt="img"></p>
<p>​                                                                                        隐式链表</p>
</li>
</ol>
<p><strong>显式链表</strong></p>
<ol>
<li><code>实现</code>：把每个Block中的next指针存储到内存<code>文件分配表</code>中，通过遍历数组方式实现拿到全部数据。</li>
<li><code>缺点</code>：前面说1KB就有个inode指针，如果磁盘数据很大那就需要很大的<strong>文件分配表</strong>来存储映射关系了。</li>
</ol>
<p><img src="img/943a1fbf-4ed2-4902-bd09-4a447dad75d4.png" alt="img"></p>
<p>​                                                                                                显示链表</p>
<h6 id="3-3-3-3-非连续空间存储之索引"><a href="#3-3-3-3-非连续空间存储之索引" class="headerlink" title="3.3.3.3 非连续空间存储之索引"></a>3.3.3.3 非连续空间存储之索引</h6><ol>
<li><code>实现</code>：整个文件类型一本新华字典，真实的数据块在词典实际位置存储着，但文件所需数据块的索引位置会被汇总起来形成目录索引放在字典前头。</li>
<li><code>优势</code>：不会产生碎片，文件可动态扩容，并且支持顺序跟随机读写。</li>
<li><code>劣势</code>：可能一个小文件都要占用一个目录索引，文件过大导致索引指针一个容不下，可能还需要有<code>多级索引</code>或<code>索引+链表</code>模式。</li>
</ol>
<p><img src="img/d682a33a-bbe7-4c44-a36f-29f9fbc6afd5.png" alt="img"></p>
<p>​                                                                                            索引存储</p>
<p>这些存储方式各有利弊，所以操作系统才存储的时候一般是根据文件的大小进行动态的变化存储方式的，跟STL中的快排底层 = 快排 + 插入排序 + 堆排 一样的道理。</p>
<h6 id="3-3-3-4-空闲空间管理"><a href="#3-3-3-4-空闲空间管理" class="headerlink" title="3.3.3.4 空闲空间管理"></a>3.3.3.4 空闲空间管理</h6><p>为了避免用户存储数据时候遍历全部磁盘空间来寻找可以数据块，一般有如下几种记录方法。</p>
<ol>
<li><p><code>空闲表</code>：动态的维护一个空闲数据块列表，每行存储空闲块的开始位置跟空闲长度。适合少量有少量空闲数据块时。</p>
<p><img src="img/4e410c99-d079-4dab-910f-56bf571eea3e.png" alt="img"></p>
</li>
<li><p><code>空闲链表</code>：将空闲的数据块用next指针串联起来，缺点是不能随机访问。</p>
<p><img src="img/9fa040fb-5559-4e11-9281-def532e5a4af.png" alt="img"></p>
</li>
<li><p><code>位图法</code>：利用Bit的 0 1 表示数据块可用跟不可用，简单方便，<strong>inode跟空闲数据库都用的此方法</strong>。</p>
</li>
</ol>
<p><img src="img/1851d524-eeec-4fb7-801e-60dd65ea933e.png" alt="img"></p>
<h4 id="3-4-输入输出管理"><a href="#3-4-输入输出管理" class="headerlink" title="3.4 输入输出管理"></a>3.4 输入输出管理</h4><h5 id="3-4-1-设备控制器跟驱动程序"><a href="#3-4-1-设备控制器跟驱动程序" class="headerlink" title="3.4.1 设备控制器跟驱动程序"></a>3.4.1 设备控制器跟驱动程序</h5><h6 id="3-4-1-1-设备控制器"><a href="#3-4-1-1-设备控制器" class="headerlink" title="3.4.1.1 设备控制器"></a>3.4.1.1 设备控制器</h6><p><img src="img/065c56b2-9615-45bb-a3f9-24dcf4c9f043.png" alt="img"></p>
<p>​                                                                                设备控制器</p>
<p>操作系统为统一管理众多的设备并且屏蔽设备之间的差异，给每个设备都安装了个小CPU叫 <strong>设备控制器</strong>。每个设备控制器都知道自己对应外设的功能跟用法，并且每个 <strong>设备控制器</strong>都有独有的寄存器用来跟CPU通信。</p>
<ol>
<li>读设备寄存器值了解设备状态，是否可以接收新指令。</li>
<li>操作系统给设备寄存器写入一些指令可以实现发送数据、接收数据等等操作。</li>
</ol>
<p>控制器一般分为<strong>数据寄存器、命令寄存器跟状态寄存器</strong>，CPU 通过读、写设备控制器中的寄存器来便捷的控制设备：</p>
<ol>
<li><code>数据寄存器</code>：CPU 向 I/O 设备写入需要传输的数据，比如打印what，CPU 就要先发送一个w字符给到对应的 I/O 设备。</li>
<li><code>命令寄存器</code>：CPU 发送命令来告诉 I/O 设备要进行输入/输出操作，于是就会交给 I/O 设备去工作，任务完成后，会把状态寄存器里面的状态标记为完成。</li>
<li><code>状态寄存器</code>：用来告诉 CPU 现在已经在工作或工作已经完成，只有状态寄存标记成已完成，CPU 才能发送下一个字符和命令。</li>
</ol>
<p>同时输入输出设备可分为<code>块设备</code>跟<code>字符设备</code>。</p>
<ol>
<li><code>块设备</code>：用来把数据存储在固定大小的块中，每个块有自己的地址，硬盘、U盘等是常见的块设备。块设备一般数据传输较大为避免频繁IO，控制器中有个可读写等<strong>数据缓冲区</strong>。Linux操作系统为屏蔽不同块设备带来的差异引入了<strong>通用块层</strong>，<strong>通用块层</strong>是处于文件系统和磁盘驱动中间的一个块设备抽象层，主要提供如下俩功能：</li>
</ol>
<blockquote>
<ol>
<li>向上为文件系统和应用程序，提供访问块设备的标准接口，向下把各种不同的磁盘设备抽象为统一的块设备，并在内核层面提供一个框架来管理这些设备的驱动程序。</li>
<li>通用层还会给文件系统和应用程序发来的 I/O进行<strong>调度</strong>，主要目的是为了提高磁盘读写的效率。</li>
</ol>
</blockquote>
<ol>
<li><code>字符设备</code>：以字符为单位发送或接收一个字符流，字符设备是不可寻址的，也没有任何寻道操作，鼠标是常见的字符设备。</li>
</ol>
<p>CPU一般通过<strong>IO端口</strong>跟<strong>内存映射IO</strong>来跟设备的控制寄存器和数据缓冲区进行通信</p>
<ol>
<li><code>IO端口</code>：每个控制寄存器被分配一个 I/O 端口，可以通过特殊的汇编指令操作这些寄存器，比如 in/out 类似的指令。</li>
<li><code>内存映射IO</code>：将所有控制寄存器映射到内存空间中，这样就可以像读写内存一样读写数据缓冲区。</li>
</ol>
<h6 id="3-4-1-2-驱动接口"><a href="#3-4-1-2-驱动接口" class="headerlink" title="3.4.1.2 驱动接口"></a>3.4.1.2 驱动接口</h6><p><img src="img/b04ad4be-a9d5-4266-9b7b-f1f0443aa6f9.png" alt="img"></p>
<p>驱动程序</p>
<p>设备控制器屏蔽了设备细节，但每种设备的控制器的寄存器、缓冲区等使用模式都是不同的，它属于硬件。在操作系统图范畴内为了屏蔽设备控制器的差异，引入了<strong>设备驱动程序</strong>，<strong>不同设备到驱动程序会提供统一接口给操作系统来调用</strong>，这样操作系统内核会像调用本地代码一样使用设备驱动程序接口。</p>
<p>设备发出IO请求就是在<strong>设备驱动程序</strong>中来响应到，它会根据中断类型调用响应到中断处理程序进行处理。</p>
<p><img src="img/77a70385-ae40-4e89-a802-1e28f16fb044.png" alt="img"></p>
<p>中断请求流程</p>
<h5 id="3-4-2-IO-控制"><a href="#3-4-2-IO-控制" class="headerlink" title="3.4.2 IO 控制"></a>3.4.2 IO 控制</h5><p>CPU发送指令让那个设备控制器去读写数据，完毕后如何通知CPU呢？</p>
<h6 id="3-4-2-1-轮询模式"><a href="#3-4-2-1-轮询模式" class="headerlink" title="3.4.2.1 轮询模式"></a>3.4.2.1 轮询模式</h6><p>控制器中有个<strong>状态寄存器</strong>，CPU不断<strong>轮</strong>询查看寄存器状态，该模式会傻瓜式的一直占用CPU。</p>
<p><img src="img/4df125eb-7c91-46ff-8cc6-809d24cf2c31.png" alt="img"></p>
<p>轮询模式</p>
<h6 id="3-4-2-2-IO-中断请求"><a href="#3-4-2-2-IO-中断请求" class="headerlink" title="3.4.2.2 IO 中断请求"></a>3.4.2.2 IO 中断请求</h6><p><img src="img/641525ba-4c14-4348-8139-4853d814251b.png" alt="img"></p>
<p>中断模式</p>
<p>控制器有个中断控制器，当设备完成任务后触发中断到中断控制器，中断控制器就通知 CPU来处理中断请求。中断有两种，一种是 <strong>软中断</strong>，比如代码调用 INT 指令触发。一种是 <strong>硬件中断</strong>，硬件通过中断控制器触发的。但中断方式对于频繁读写磁盘数据的操作就不太友好了，会频繁打断CPU。</p>
<p>这里说下磁盘高速缓存 <strong>PageCache</strong>，它是用来缓存最近被CPU访问的数据到内存中，并且还具有预读功能，可能你读前16KB数据，已经把后16KB数据给你缓存好了。</p>
<blockquote>
<ol>
<li><strong>pagecache</strong> : 页缓存，当进程需读取磁盘文件时，linux先分配一些内存，将数据从磁盘读区到内存中，然后再将数据传给进程。当进程需写数据到磁盘时，linux先分配内存接收用户数据，然后再将数据从内存写到磁盘。同时pagecache由于大小受限，所以一般只缓存最近被访问的数据，数据不足时还需访问磁盘。</li>
</ol>
</blockquote>
<h6 id="3-4-2-3-DMA-模式"><a href="#3-4-2-3-DMA-模式" class="headerlink" title="3.4.2.3 DMA 模式"></a>3.4.2.3 DMA 模式</h6><p><code>Direct Memory Access</code> 直接内存访问，在硬件DMA控制器的支持下，<strong>在进行 I/O 设备和内存的数据传输的时候，数据搬运的工作全部交给 DMA 控制器，而 CPU 不再参与任何与数据搬运相关的事情，让CPU 去处理别的事</strong>。</p>
<p><img src="img/6fea9b11-6cb1-4043-b3b5-b688cbf3df5f.png" alt="img"></p>
<p>DMA模式</p>
<p>可以发现整个数据传输过程中CPU是不会直接参与数据搬运工作，由DMA来直接负责数据读取工作，现如今每个IO设备一般都自带DMA控制器。读数据时候仅仅在传送开始跟结束时需要CPU干预。</p>
<h6 id="3-4-2-4-Zero-Copy"><a href="#3-4-2-4-Zero-Copy" class="headerlink" title="3.4.2.4 Zero Copy"></a>3.4.2.4 Zero Copy</h6><p>Zero Copy 全程不会通过 CPU 来搬运数据，所有的数据都是通过 DMA 来进行传输的，中间只需要经过2次上下文切换跟2次DMA数据拷贝，相比最原始读写方式至少速度翻倍。其实在Kafka中已经讲过Zero Copy了。</p>
<ol>
<li><strong>老版本读写</strong></li>
</ol>
<p>老版本的简单读写操作中间不对数据做任何操作。期间会发生<strong>4次用户态跟内核态的切换。2次DMA数据拷贝，2次CPU数据拷贝</strong>。</p>
<p><img src="img/82145022-6640-46f3-89b4-5755f819363e.png" alt="img"></p>
<p>老式读写</p>
<p>提速方法就是需减少用户态与内核态的上下文切换和内存拷贝的次数。数据传输时从内核的读缓冲区拷贝到用户的缓冲区，再从用户缓冲区拷贝到 socket 缓冲区的这个过程是没有必要的。接下来</p>
<p>接下来按照三个版本说下Zero Copy 发展史。</p>
<ol start="2">
<li><strong>mmap 跟 write</strong></li>
</ol>
<p><img src="img/1cbd9302-47c4-4529-9a85-94d5758554d4.png" alt="img"></p>
<p>mmap + write</p>
<p>思路就是用 <strong>mmap</strong>替代read函数，mmap调用时会 <strong>直接把内核缓冲区里的数据映射到用户空间</strong>，此时减少了一次数据拷贝，但仍然需要通过 CPU 把内核缓冲区的数据拷贝到 socket 缓冲区里，而且仍然需要 4 次上下文切换，因为系统调用还是 2 次。</p>
<pre class="line-numbers language-c" data-language="c"><code class="language-c">buf <span class="token operator">=</span> <span class="token function">mmap</span><span class="token punctuation">(</span>file<span class="token punctuation">,</span> len<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token function">write</span><span class="token punctuation">(</span>sockfd<span class="token punctuation">,</span> buf<span class="token punctuation">,</span> len<span class="token punctuation">)</span><span class="token punctuation">;</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre>

<ol start="3">
<li><strong>sendfile</strong></li>
</ol>
<p>Linux 内核版本 2.1版本提供了函数 **sendfile()**。</p>
<pre class="line-numbers language-c" data-language="c"><code class="language-c"><span class="token class-name">ssize_t</span> <span class="token function">sendfile</span><span class="token punctuation">(</span><span class="token keyword">int</span> out_fd<span class="token punctuation">,</span> <span class="token keyword">int</span> in_fd<span class="token punctuation">,</span> <span class="token class-name">off_t</span> <span class="token operator">*</span>offset<span class="token punctuation">,</span> <span class="token class-name">size_t</span> count<span class="token punctuation">)</span><span class="token punctuation">;</span>
out_fd <span class="token operator">:</span> 目的文件描述符
in_fd<span class="token operator">:</span>源文件描述符
offset<span class="token operator">:</span>源文件内偏移量
count<span class="token operator">:</span>打算复制数据长度
<span class="token class-name">ssize_t</span><span class="token operator">:</span>实际上复制数据的长度<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre>

<p>可以发现一个 sendfile = read + write，避免了2次用户态跟内核态来回切换，并且可以直接把内核缓冲区里的数据拷贝到 socket 缓冲区里，这样就只有 2 次上下文切换，和 3 次数据拷贝。</p>
<p><img src="img/094bdae3-2812-44da-8f26-ca41a9ecacb6.png" alt="img"></p>
<p>sendfile模式</p>
<ol start="4">
<li> <strong>真正的零拷贝</strong></li>
</ol>
<p>Linux 内核 2.4如果网卡支持SG-DMA 技术，可以减少通过 CPU 把内核缓冲区里的数据拷贝到 socket 缓冲区的过程。</p>
<pre class="line-numbers language-none"><code class="language-none">$ ethtool -k eth0 | grep scatter-gather
scatter-gather: on<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre>

<p>SG-DMA 技术可以直接将内核缓存中的数据拷贝到网卡的缓冲区里，此过程不需要将数据从操作系统内核缓冲区拷贝到 socket 缓冲区中，这样就减少了一次数据拷贝。</p>
<p><img src="img/a085e844-bc5a-43a8-9fb6-c47cd44e2136.png" alt="img"></p>
<p>ZeroCopy</p>
<ol start="5">
<li><strong>文件传输规则</strong></li>
</ol>
<p>不要以为会了Zero Copy后，无论大小文件都用Zero Copy。实际工作中一般小文件采用Zero Copy技术，而大文件会用异步IO。至于为啥，且看如下分析：</p>
<p>前面说的数据从磁盘读到内核缓冲区就是读到PageCache中，PageCache具有缓存跟预读功能。但当传输超大文件时PageCache会不失效，因为大文件会快速占满PageCache区，但这些文件又只是一次访问，会造成其他热点小文件无法使用PageCache，所以索性不用PageCache，使用异步IO的了。至于异步IO是啥呢？下文在说。</p>
<h5 id="3-4-3-IO分层"><a href="#3-4-3-IO分层" class="headerlink" title="3.4.3 IO分层"></a>3.4.3 IO分层</h5><p><img src="img/73d0cbeb-9069-4c65-bb1d-4192231ac390.png" alt="img"></p>
<p>IO分层</p>
<p>Linux 存储系统的 I/O 由上到下可以分为 <strong>文件系统层</strong>、 <strong>通用块层</strong>、 <strong>设备层</strong>。</p>
<ol>
<li>文件系统层向上为应用程序统一提供了标准的文件访问接口，向下会通过通用块层来存储和管理磁盘数据。</li>
<li>通用块层包括块设备的 I/O 队列和 I/O 调度器，通过IO调度器处理IO请求。</li>
<li>设备层包括硬件设备、设备控制器和驱动程序，负责最终物理设备的 I/O 操作。</li>
</ol>
<p>Linux系统中的IO<strong>读取提速</strong>：</p>
<ol>
<li>为提高文件访问效率会使用页缓存、索引节点缓存、目录项缓存等多种缓存机制，目的是为了减少对块设备的直接调用。</li>
<li>为了提高块设备的访问效率， 会使用缓冲区，来缓存块设备的数据。</li>
</ol>

                
            </div>
            <hr/>

            

    <div class="reprint" id="reprint-statement">
        
            <div class="reprint__author">
                <span class="reprint-meta" style="font-weight: bold;">
                    <i class="fas fa-user">
                        Author:
                    </i>
                </span>
                <span class="reprint-info">
                    <a href="/about" rel="external nofollow noreferrer">凡诚</a>
                </span>
            </div>
            <div class="reprint__type">
                <span class="reprint-meta" style="font-weight: bold;">
                    <i class="fas fa-link">
                        Link:
                    </i>
                </span>
                <span class="reprint-info">
                    <a href="http://example.com/2020/03/11/ji-suan-ji-ji-chu/">http://example.com/2020/03/11/ji-suan-ji-ji-chu/</a>
                </span>
            </div>
            <div class="reprint__notice">
                <span class="reprint-meta" style="font-weight: bold;">
                    <i class="fas fa-copyright">
                        Reprint policy:
                    </i>
                </span>
                <span class="reprint-info">
                    All articles in this blog are used except for special statements
                    <a href="https://creativecommons.org/licenses/by/4.0/deed.zh" rel="external nofollow noreferrer" target="_blank">CC BY 4.0</a>
                    reprint polocy. If reproduced, please indicate source
                    <a href="/about" target="_blank">凡诚</a>
                    !
                </span>
            </div>
        
    </div>

    <script async defer>
      document.addEventListener("copy", function (e) {
        let toastHTML = '<span>Copied successfully, please follow the reprint policy of this article</span><button class="btn-flat toast-action" onclick="navToReprintStatement()" style="font-size: smaller">more</a>';
        M.toast({html: toastHTML})
      });

      function navToReprintStatement() {
        $("html, body").animate({scrollTop: $("#reprint-statement").offset().top - 80}, 800);
      }
    </script>



            <div class="tag_share" style="display: block;">
                <div class="post-meta__tag-list" style="display: inline-block;">
                    
                        <div class="article-tag">
                            
                                <a href="/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%9F%BA%E7%A1%80/">
                                    <span class="chip bg-color">计算机基础</span>
                                </a>
                            
                        </div>
                    
                </div>
                <div class="post_share" style="zoom: 80%; width: fit-content; display: inline-block; float: right; margin: -0.15rem 0;">
                    <link rel="stylesheet" type="text/css" href="/libs/share/css/share.min.css">
<div id="article-share">

    
    <div class="social-share" data-sites="twitter,facebook,google,qq,qzone,wechat,weibo,douban,linkedin" data-wechat-qrcode-helper="<p>微信扫一扫即可分享！</p>"></div>
    <script src="/libs/share/js/social-share.min.js"></script>
    

    

</div>

                </div>
            </div>
            
                <style>
    #reward {
        margin: 40px 0;
        text-align: center;
    }

    #reward .reward-link {
        font-size: 1.4rem;
        line-height: 38px;
    }

    #reward .btn-floating:hover {
        box-shadow: 0 6px 12px rgba(0, 0, 0, 0.2), 0 5px 15px rgba(0, 0, 0, 0.2);
    }

    #rewardModal {
        width: 320px;
        height: 350px;
    }

    #rewardModal .reward-title {
        margin: 15px auto;
        padding-bottom: 5px;
    }

    #rewardModal .modal-content {
        padding: 10px;
    }

    #rewardModal .close {
        position: absolute;
        right: 15px;
        top: 15px;
        color: rgba(0, 0, 0, 0.5);
        font-size: 1.3rem;
        line-height: 20px;
        cursor: pointer;
    }

    #rewardModal .close:hover {
        color: #ef5350;
        transform: scale(1.3);
        -moz-transform:scale(1.3);
        -webkit-transform:scale(1.3);
        -o-transform:scale(1.3);
    }

    #rewardModal .reward-tabs {
        margin: 0 auto;
        width: 210px;
    }

    .reward-tabs .tabs {
        height: 38px;
        margin: 10px auto;
        padding-left: 0;
    }

    .reward-content ul {
        padding-left: 0 !important;
    }

    .reward-tabs .tabs .tab {
        height: 38px;
        line-height: 38px;
    }

    .reward-tabs .tab a {
        color: #fff;
        background-color: #ccc;
    }

    .reward-tabs .tab a:hover {
        background-color: #ccc;
        color: #fff;
    }

    .reward-tabs .wechat-tab .active {
        color: #fff !important;
        background-color: #22AB38 !important;
    }

    .reward-tabs .alipay-tab .active {
        color: #fff !important;
        background-color: #019FE8 !important;
    }

    .reward-tabs .reward-img {
        width: 210px;
        height: 210px;
    }
</style>

<div id="reward">
    <a href="#rewardModal" class="reward-link modal-trigger btn-floating btn-medium waves-effect waves-light red">赏</a>

    <!-- Modal Structure -->
    <div id="rewardModal" class="modal">
        <div class="modal-content">
            <a class="close modal-close"><i class="fas fa-times"></i></a>
            <h4 class="reward-title">你的赏识是我前进的动力</h4>
            <div class="reward-content">
                <div class="reward-tabs">
                    <ul class="tabs row">
                        <li class="tab col s6 alipay-tab waves-effect waves-light"><a href="#alipay">支付宝</a></li>
                        <li class="tab col s6 wechat-tab waves-effect waves-light"><a href="#wechat">微 信</a></li>
                    </ul>
                    <div id="alipay">
                        <img src="/medias/reward/alipay.jpg" class="reward-img" alt="支付宝打赏二维码">
                    </div>
                    <div id="wechat">
                        <img src="/medias/reward/wechat.png" class="reward-img" alt="微信打赏二维码">
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>

<script>
    $(function () {
        $('.tabs').tabs();
    });
</script>

            
        </div>
    </div>

    

    

    

    
    <div class="livere-card card" data-aos="fade-up">
    <!-- 来必力City版安装代码 -->
    <div id="lv-container" class="card-content" data-id="city" data-uid="MTAyMC81NzU4NC8zNDA0OA==">
        <script type="text/javascript">
            (function (d, s) {
                let j, e = d.getElementsByTagName(s)[0];
                if (typeof LivereTower === 'function') {
                    return;
                }

                j = d.createElement(s);
                j.src = 'https://cdn-city.livere.com/js/embed.dist.js';
                j.async = true;

                e.parentNode.insertBefore(j, e);
            })(document, 'script');
        </script>
        <noscript>为正常使用来必力评论功能请激活JavaScript。</noscript>
    </div>
    <!-- City版安装代码已完成 -->
</div>
    

    

    

    

    

<article id="prenext-posts" class="prev-next articles">
    <div class="row article-row">
        
        <div class="article col s12 m6" data-aos="fade-up">
            <div class="article-badge left-badge text-color">
                <i class="fas fa-chevron-left"></i>&nbsp;Previous</div>
            <div class="card">
                <a href="/2020/05/08/java-ji-chu/">
                    <div class="card-image">
                        
                        
                        <img src="/medias/featureimages/2.jpg" class="responsive-img" alt="java基础">
                        
                        <span class="card-title">java基础</span>
                    </div>
                </a>
                <div class="card-content article-content">
                    <div class="summary block-with-text">
                        
                            Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。
                        
                    </div>
                    <div class="publish-info">
                        <span class="publish-date">
                            <i class="far fa-clock fa-fw icon-date"></i>2020-05-08
                        </span>
                        <span class="publish-author">
                            
                            <i class="fas fa-bookmark fa-fw icon-category"></i>
                            
                            <a href="/categories/%E5%90%8E%E7%AB%AF%E6%8A%80%E6%9C%AF/" class="post-category">
                                    后端技术
                                </a>
                            
                            
                        </span>
                    </div>
                </div>
                
                <div class="card-action article-tags">
                    
                    <a href="/tags/java/">
                        <span class="chip bg-color">java</span>
                    </a>
                    
                </div>
                
            </div>
        </div>
        
        
        <div class="article col s12 m6" data-aos="fade-up">
            <div class="article-badge right-badge text-color">
                Next&nbsp;<i class="fas fa-chevron-right"></i>
            </div>
            <div class="card">
                <a href="/2020/02/08/git-ji-chu/">
                    <div class="card-image">
                        
                        
                        <img src="/medias/featureimages/0.jpg" class="responsive-img" alt="git基础">
                        
                        <span class="card-title">git基础</span>
                    </div>
                </a>
                <div class="card-content article-content">
                    <div class="summary block-with-text">
                        
                            Git是一个开源的分布式版本控制系统，可以有效、高速地处理从很小到非常大的项目版本管理。
                        
                    </div>
                    <div class="publish-info">
                            <span class="publish-date">
                                <i class="far fa-clock fa-fw icon-date"></i>2020-02-08
                            </span>
                        <span class="publish-author">
                            
                            <i class="fas fa-bookmark fa-fw icon-category"></i>
                            
                            <a href="/categories/%E5%8D%8F%E5%90%8C%E5%BC%80%E5%8F%91/" class="post-category">
                                    协同开发
                                </a>
                            
                            
                        </span>
                    </div>
                </div>
                
                <div class="card-action article-tags">
                    
                    <a href="/tags/git/">
                        <span class="chip bg-color">git</span>
                    </a>
                    
                </div>
                
            </div>
        </div>
        
    </div>
</article>

</div>



<!-- 代码块功能依赖 -->
<script type="text/javascript" src="/libs/codeBlock/codeBlockFuction.js"></script>

<!-- 代码语言 -->

<script type="text/javascript" src="/libs/codeBlock/codeLang.js"></script>


<!-- 代码块复制 -->

<script type="text/javascript" src="/libs/codeBlock/codeCopy.js"></script>


<!-- 代码块收缩 -->

<script type="text/javascript" src="/libs/codeBlock/codeShrink.js"></script>


    </div>
    <div id="toc-aside" class="expanded col l3 hide-on-med-and-down">
        <div class="toc-widget card" style="background-color: white;">
            <div class="toc-title"><i class="far fa-list-alt"></i>&nbsp;&nbsp;TOC</div>
            <div id="toc-content"></div>
        </div>
    </div>
</div>

<!-- TOC 悬浮按钮. -->

<div id="floating-toc-btn" class="hide-on-med-and-down">
    <a class="btn-floating btn-large bg-color">
        <i class="fas fa-list-ul"></i>
    </a>
</div>


<script src="/libs/tocbot/tocbot.min.js"></script>
<script>
    $(function () {
        tocbot.init({
            tocSelector: '#toc-content',
            contentSelector: '#articleContent',
            headingsOffset: -($(window).height() * 0.4 - 45),
            collapseDepth: Number('0'),
            headingSelector: 'h2, h3, h4'
        });

        // modify the toc link href to support Chinese.
        let i = 0;
        let tocHeading = 'toc-heading-';
        $('#toc-content a').each(function () {
            $(this).attr('href', '#' + tocHeading + (++i));
        });

        // modify the heading title id to support Chinese.
        i = 0;
        $('#articleContent').children('h2, h3, h4').each(function () {
            $(this).attr('id', tocHeading + (++i));
        });

        // Set scroll toc fixed.
        let tocHeight = parseInt($(window).height() * 0.4 - 64);
        let $tocWidget = $('.toc-widget');
        $(window).scroll(function () {
            let scroll = $(window).scrollTop();
            /* add post toc fixed. */
            if (scroll > tocHeight) {
                $tocWidget.addClass('toc-fixed');
            } else {
                $tocWidget.removeClass('toc-fixed');
            }
        });

        
        /* 修复文章卡片 div 的宽度. */
        let fixPostCardWidth = function (srcId, targetId) {
            let srcDiv = $('#' + srcId);
            if (srcDiv.length === 0) {
                return;
            }

            let w = srcDiv.width();
            if (w >= 450) {
                w = w + 21;
            } else if (w >= 350 && w < 450) {
                w = w + 18;
            } else if (w >= 300 && w < 350) {
                w = w + 16;
            } else {
                w = w + 14;
            }
            $('#' + targetId).width(w);
        };

        // 切换TOC目录展开收缩的相关操作.
        const expandedClass = 'expanded';
        let $tocAside = $('#toc-aside');
        let $mainContent = $('#main-content');
        $('#floating-toc-btn .btn-floating').click(function () {
            if ($tocAside.hasClass(expandedClass)) {
                $tocAside.removeClass(expandedClass).hide();
                $mainContent.removeClass('l9');
            } else {
                $tocAside.addClass(expandedClass).show();
                $mainContent.addClass('l9');
            }
            fixPostCardWidth('artDetail', 'prenext-posts');
        });
        
    });
</script>

    

</main>




    <footer class="page-footer bg-color">
    
        <link rel="stylesheet" href="/libs/aplayer/APlayer.min.css">
<style>
    .aplayer .aplayer-lrc p {
        
        font-size: 12px;
        font-weight: 700;
        line-height: 16px !important;
    }

    .aplayer .aplayer-lrc p.aplayer-lrc-current {
        
        font-size: 15px;
        color: blue;
    }

    
    .aplayer.aplayer-fixed.aplayer-narrow .aplayer-body {
        left: -66px !important;
    }

    .aplayer.aplayer-fixed.aplayer-narrow .aplayer-body:hover {
        left: 0px !important;
    }

    
</style>
<div class="">
    
    <div class="row">
        <meting-js class="col l8 offset-l2 m10 offset-m1 s12"
                   server="netease"
                   type="playlist"
                   id="2477330090"
                   fixed='true'
                   autoplay='false'
                   theme='blue'
                   loop='all'
                   order='random'
                   preload='auto'
                   volume='0.7'
                   list-folded='true'
        >
        </meting-js>
    </div>
</div>

<script src="/libs/aplayer/APlayer.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/meting@2/dist/Meting.min.js"></script>

    
    <div class="container row center-align" style="margin-bottom: 15px !important;">
        <div class="col s12 m8 l8 copy-right">
            Copyright&nbsp;&copy;
            
                <span id="year">2022</span>
            
            <span id="year">2022</span>
            <a href="/about" target="_blank">凡诚</a>
            &nbsp;&nbsp;<a href="https://hexo.io/" target="_blank"></a>
            |&nbsp;Theme&nbsp;<a href="https://github.com/blinkfox/hexo-theme-matery" target="_blank">Matery</a>
            <br>
            
            &nbsp;<i class="fas fa-chart-area"></i>&nbsp;站点总字数:&nbsp;<span
                class="white-color">607.1k</span>&nbsp;字
            
            
            
            
            
            
            <span id="busuanzi_container_site_pv">
                |&nbsp;<i class="far fa-eye"></i>&nbsp;总访问量:&nbsp;<span id="busuanzi_value_site_pv"
                    class="white-color"></span>&nbsp;次
            </span>
            
            
            <span id="busuanzi_container_site_uv">
                |&nbsp;<i class="fas fa-users"></i>&nbsp;总访问人数:&nbsp;<span id="busuanzi_value_site_uv"
                    class="white-color"></span>&nbsp;人
            </span>
            
            <br>
            
            <span id="sitetime">载入运行时间...</span>
            <script>
                function siteTime() {
                    var seconds = 1000;
                    var minutes = seconds * 60;
                    var hours = minutes * 60;
                    var days = hours * 24;
                    var years = days * 365;
                    var today = new Date();
                    var startYear = "2022";
                    var startMonth = "11";
                    var startDate = "7";
                    var startHour = "0";
                    var startMinute = "0";
                    var startSecond = "0";
                    var todayYear = today.getFullYear();
                    var todayMonth = today.getMonth() + 1;
                    var todayDate = today.getDate();
                    var todayHour = today.getHours();
                    var todayMinute = today.getMinutes();
                    var todaySecond = today.getSeconds();
                    var t1 = Date.UTC(startYear, startMonth, startDate, startHour, startMinute, startSecond);
                    var t2 = Date.UTC(todayYear, todayMonth, todayDate, todayHour, todayMinute, todaySecond);
                    var diff = t2 - t1;
                    var diffYears = Math.floor(diff / years);
                    var diffDays = Math.floor((diff / days) - diffYears * 365);
                    var diffHours = Math.floor((diff - (diffYears * 365 + diffDays) * days) / hours);
                    var diffMinutes = Math.floor((diff - (diffYears * 365 + diffDays) * days - diffHours * hours) /
                        minutes);
                    var diffSeconds = Math.floor((diff - (diffYears * 365 + diffDays) * days - diffHours * hours -
                        diffMinutes * minutes) / seconds);
                    if (startYear == todayYear) {
                        document.getElementById("year").innerHTML = todayYear;
                        document.getElementById("sitetime").innerHTML = "本站已安全运行 " + diffDays + " 天 " + diffHours +
                            " 小时 " + diffMinutes + " 分钟 " + diffSeconds + " 秒";
                    } else {
                        document.getElementById("year").innerHTML = startYear + " - " + todayYear;
                        document.getElementById("sitetime").innerHTML = "本站已安全运行 " + diffYears + " 年 " + diffDays +
                            " 天 " + diffHours + " 小时 " + diffMinutes + " 分钟 " + diffSeconds + " 秒";
                    }
                }
                setInterval(siteTime, 1000);
            </script>
            
            <br>
            
        </div>
        <div class="col s12 m4 l4 social-link social-statis">
    <a href="https://github.com/fanshicheng" class="tooltipped" target="_blank" data-tooltip="访问我的GitHub" data-position="top" data-delay="50">
        <i class="fab fa-github"></i>
    </a>



    <a href="mailto:2639144944@qq.com" class="tooltipped" target="_blank" data-tooltip="邮件联系我" data-position="top" data-delay="50">
        <i class="fas fa-envelope-open"></i>
    </a>







    <a href="tencent://AddContact/?fromId=50&fromSubId=1&subcmd=all&uin=2639144944" class="tooltipped" target="_blank" data-tooltip="QQ联系我: 2639144944" data-position="top" data-delay="50">
        <i class="fab fa-qq"></i>
    </a>







</div>
    </div>
</footer>

<div class="progress-bar"></div>


    <!-- 搜索遮罩框 -->
<div id="searchModal" class="modal">
    <div class="modal-content">
        <div class="search-header">
            <span class="title"><i class="fas fa-search"></i>&nbsp;&nbsp;Search</span>
            <input type="search" id="searchInput" name="s" placeholder="Please enter a search keyword"
                   class="search-input">
        </div>
        <div id="searchResult"></div>
    </div>
</div>

<script type="text/javascript">
$(function () {
    var searchFunc = function (path, search_id, content_id) {
        'use strict';
        $.ajax({
            url: path,
            dataType: "xml",
            success: function (xmlResponse) {
                // get the contents from search data
                var datas = $("entry", xmlResponse).map(function () {
                    return {
                        title: $("title", this).text(),
                        content: $("content", this).text(),
                        url: $("url", this).text()
                    };
                }).get();
                var $input = document.getElementById(search_id);
                var $resultContent = document.getElementById(content_id);
                $input.addEventListener('input', function () {
                    var str = '<ul class=\"search-result-list\">';
                    var keywords = this.value.trim().toLowerCase().split(/[\s\-]+/);
                    $resultContent.innerHTML = "";
                    if (this.value.trim().length <= 0) {
                        return;
                    }
                    // perform local searching
                    datas.forEach(function (data) {
                        var isMatch = true;
                        var data_title = data.title.trim().toLowerCase();
                        var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
                        var data_url = data.url;
                        data_url = data_url.indexOf('/') === 0 ? data.url : '/' + data_url;
                        var index_title = -1;
                        var index_content = -1;
                        var first_occur = -1;
                        // only match artiles with not empty titles and contents
                        if (data_title !== '' && data_content !== '') {
                            keywords.forEach(function (keyword, i) {
                                index_title = data_title.indexOf(keyword);
                                index_content = data_content.indexOf(keyword);
                                if (index_title < 0 && index_content < 0) {
                                    isMatch = false;
                                } else {
                                    if (index_content < 0) {
                                        index_content = 0;
                                    }
                                    if (i === 0) {
                                        first_occur = index_content;
                                    }
                                }
                            });
                        }
                        // show search results
                        if (isMatch) {
                            str += "<li><a href='" + data_url + "' class='search-result-title'>" + data_title + "</a>";
                            var content = data.content.trim().replace(/<[^>]+>/g, "");
                            if (first_occur >= 0) {
                                // cut out 100 characters
                                var start = first_occur - 20;
                                var end = first_occur + 80;
                                if (start < 0) {
                                    start = 0;
                                }
                                if (start === 0) {
                                    end = 100;
                                }
                                if (end > content.length) {
                                    end = content.length;
                                }
                                var match_content = content.substr(start, end);
                                // highlight all keywords
                                keywords.forEach(function (keyword) {
                                    var regS = new RegExp(keyword, "gi");
                                    match_content = match_content.replace(regS, "<em class=\"search-keyword\">" + keyword + "</em>");
                                });

                                str += "<p class=\"search-result\">" + match_content + "...</p>"
                            }
                            str += "</li>";
                        }
                    });
                    str += "</ul>";
                    $resultContent.innerHTML = str;
                });
            }
        });
    };

    searchFunc('/search.xml', 'searchInput', 'searchResult');
});
</script>

    <!-- 回到顶部按钮 -->
<div id="backTop" class="top-scroll">
    <a class="btn-floating btn-large waves-effect waves-light" href="#!">
        <i class="fas fa-arrow-up"></i>
    </a>
</div>

    <script type="text/javascript">
        var OriginTitile=document.title,st;
        document.addEventListener("visibilitychange",function(){
            document.hidden?(document.title="(Ő∀Ő3)ノ",clearTimeout(st)):(document.title="ヽ(●-`Д´-)ノ欢迎回来",st=setTimeout(function(){document.title=OriginTitile},3e3))
        })
    </script>
    <!-- <script src="/js/cursor.js"></script> -->
    <script type="text/javascript">
        //只在桌面版网页启用特效
        var windowWidth = $(window).width();
        if (windowWidth > 768) {
            document.write('<script type="text/javascript" src="/js/sakura.js"><\/script>');
        }
        </script>
    <script src="/libs/materialize/materialize.min.js"></script>
    <script src="/libs/masonry/masonry.pkgd.min.js"></script>
    <script src="/libs/aos/aos.js"></script>
    <script src="/libs/scrollprogress/scrollProgress.min.js"></script>
    <script src="/libs/lightGallery/js/lightgallery-all.min.js"></script>
    <script src="/js/matery.js"></script>

    <!-- Baidu Analytics -->

    <!-- Baidu Push -->

<script>
    (function () {
        var bp = document.createElement('script');
        var curProtocol = window.location.protocol.split(':')[0];
        if (curProtocol === 'https') {
            bp.src = 'https://zz.bdstatic.com/linksubmit/push.js';
        } else {
            bp.src = 'http://push.zhanzhang.baidu.com/push.js';
        }
        var s = document.getElementsByTagName("script")[0];
        s.parentNode.insertBefore(bp, s);
    })();
</script>

    
    
    <script async src="/libs/others/busuanzi.pure.mini.js"></script>
    

    

    
    <script>
        (function (i, s, o, g, r, a, m) {
            i["DaoVoiceObject"] = r;
            i[r] = i[r] || function () {
                (i[r].q = i[r].q || []).push(arguments)
            }, i[r].l = 1 * new Date();
            a = s.createElement(o), m = s.getElementsByTagName(o)[0];
            a.async = 1;
            a.src = g;
            a.charset = "utf-8";
            m.parentNode.insertBefore(a, m)
        })(window, document, "script", ('https:' == document.location.protocol ? 'https:' : 'http:') +
            "//widget.daovoice.io/widget/6984b559.js", "daovoice")
        daovoice('init', {
            app_id: "377cb7de"
        });
        daovoice('update');
    </script>
    

	
    
    <script type="text/javascript" color="0,0,255"
        pointColor="0,0,255" opacity='0.7'
        zIndex="-1" count="99"
        src="/libs/background/canvas-nest.js"></script>
    

    

    

    
    <script src="/libs/instantpage/instantpage.js" type="module"></script>
    
    <!-- 冒泡 -->
    
<canvas class="fireworks" style="position: fixed;left: 0;top: 0;z-index: 1; pointer-events: none;" ></canvas> 
<script type="text/javascript" src="//cdn.bootcss.com/animejs/2.2.0/anime.min.js"></script> 
<script type="text/javascript" src="/js/fireworks.js"></script>


</body>

</html>
